pixelkiln 0.35.0 → 0.37.0

package/dist/index.js

@@ -170,6 +170,18 @@ var StyleObjectSchema = z.object({
    * chocolate bar.
    */
   palette: z.array(HexColorSchema).default([]),
+  /**
+   * Snap every visible pixel of the downloaded art to the nearest `palette`
+   * colour, without dithering. The palette is sent to providers that take
+   * one, and most honour it most of the time; this makes it a guarantee
+   * for every generator, including the ones with no palette parameter.
+   * Applied by `fetch` as the file is written and recorded on the lock
+   * entry, so a restore reproduces the same bytes. Turning it on or off
+   * does not change the spec hash: `plan` reports the entry as recoverable
+   * and the next `fetch` or `restore` re-applies it from the art already
+   * on disk or in the cache, spending nothing.
+   */
+  enforcePalette: z.boolean().default(false),
   /** Fail-closed native-grid, palette, and human-approval policy for derived art. */
   quality: QualityProfileSchema.optional(),
   /**
@@ -211,6 +223,13 @@ var StyleSchema = StyleObjectSchema.refine((s) => !(s.tileFeature && s.styleImag
       path: ["quality"]
     });
   }
+  if (style.enforcePalette && style.palette.length < 2) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "enforcePalette needs a palette of at least two colours to snap to",
+      path: ["enforcePalette"]
+    });
+  }
 });
 var InheritedStyleSchema = StyleObjectSchema.partial().extend({
   extends: z.string().min(1),
@@ -333,7 +352,21 @@ var LockOutputSchema = z.object({
   path: z.string(),
   sha256: z.string(),
   role: z.string().optional(),
-  mediaType: MediaTypeSchema.optional()
+  mediaType: MediaTypeSchema.optional(),
+  /**
+   * Hash of the provider's bytes before post-processing changed them, when
+   * it did. The content cache keeps both, so the post-processing can be
+   * undone or redone without contacting the provider.
+   */
+  raw: z.string().optional()
+});
+var PostprocessSchema = z.object({
+  palette: z.object({
+    /** Canonical lowercase `#rrggbb` values, in manifest order. */
+    colors: z.array(z.string()).min(2).max(256),
+    dither: z.literal("none"),
+    distance: z.literal("redmean")
+  }).optional()
 });
 var LockSourceSchema = z.object({
   url: z.string(),
@@ -359,6 +392,7 @@ var LockHistoryEntrySchema = z.object({
   cost: z.number().finite().nonnegative().default(0),
   costUnit: z.string().min(1).default("generations"),
   provider: z.string().default("pixellab"),
+  postprocess: PostprocessSchema.optional(),
   /** When the replacement was submitted. */
   retiredAt: z.string()
 });
@@ -430,14 +464,7 @@ var LockEntrySchema = z.object({
    * `role` labels non-primary artifacts (e.g. "portrait", "spriteframes") so a
    * consumer can find the one it wants without pattern-matching on paths.
    */
-  outputs: z.array(
-    z.object({
-      path: z.string(),
-      sha256: z.string(),
-      role: z.string().optional(),
-      mediaType: MediaTypeSchema.optional()
-    })
-  ).default([]),
+  outputs: z.array(LockOutputSchema).default([]),
   /**
    * Provider-owned data retained for downstream consumers, namespaced by
    * provider id. PixelLab connectable sets keep their exact `tileRules` here
@@ -453,7 +480,9 @@ var LockEntrySchema = z.object({
   /** Which provider produced this. Absent on entries written before providers. */
   provider: z.string().default("pixellab"),
   /** Generations this entry replaced, newest first; see LockHistoryEntrySchema. */
-  history: z.array(LockHistoryEntrySchema).optional()
+  history: z.array(LockHistoryEntrySchema).optional(),
+  /** Post-processing applied to the recorded outputs; absent when the bytes are the provider's. */
+  postprocess: PostprocessSchema.optional()
 });
 var LockSchema = z.object({
   version: z.literal(2),
@@ -474,6 +503,72 @@ function lockKey(styleId, assetId) {
   return `${styleId}/${assetId}`;
 }
 
+// src/errors.ts
+var EXIT_CODES = {
+  usage: 2,
+  project: 3,
+  provider: 4,
+  "refused-overwrite": 5,
+  budget: 6,
+  capability: 7
+};
+var PixelKilnError = class extends Error {
+  code;
+  hint;
+  constructor(message6, code, opts = {}) {
+    super(message6, opts.cause === void 0 ? void 0 : { cause: opts.cause });
+    this.name = "PixelKilnError";
+    this.code = code;
+    if (opts.hint) this.hint = opts.hint;
+  }
+};
+var UsageError = class extends PixelKilnError {
+  constructor(message6, opts) {
+    super(message6, "usage", opts);
+    this.name = "UsageError";
+  }
+};
+var ProjectError = class extends PixelKilnError {
+  constructor(message6, opts) {
+    super(message6, "project", opts);
+    this.name = "ProjectError";
+  }
+};
+var ProviderError = class extends PixelKilnError {
+  /** Registry id of the provider that failed. */
+  provider;
+  /** HTTP status when the failure was a response, otherwise undefined. */
+  status;
+  constructor(provider, message6, opts = {}) {
+    super(message6, "provider", opts);
+    this.name = "ProviderError";
+    this.provider = provider;
+    if (opts.status !== void 0) this.status = opts.status;
+  }
+};
+var OverwriteRefusedError = class extends PixelKilnError {
+  /** The file(s) left untouched. */
+  files;
+  constructor(message6, files, opts) {
+    super(message6, "refused-overwrite", opts);
+    this.name = "OverwriteRefusedError";
+    this.files = files;
+  }
+};
+var BudgetError = class extends PixelKilnError {
+  constructor(message6, opts) {
+    super(message6, "budget", opts);
+    this.name = "BudgetError";
+  }
+};
+function errorCode(err) {
+  return err instanceof PixelKilnError ? err.code : void 0;
+}
+function exitCodeFor(err) {
+  const code = errorCode(err);
+  return code ? EXIT_CODES[code] : 1;
+}
+
 // src/client.ts
 import { z as z2 } from "zod";
 
@@ -590,14 +685,12 @@ function validateResponse(schema, raw, operation) {
   const issues = parsed.error.issues.slice(0, 4).map((i) => `${i.path.join(".") || "response"}: ${i.message}`).join("; ");
   throw new Error(`Invalid PixelLab response for ${operation}: ${issues}`);
 }
-var PixelLabError = class extends Error {
+var PixelLabError = class extends ProviderError {
   constructor(message6, status, body) {
-    super(message6);
-    this.status = status;
+    super("pixellab", message6, { status });
     this.body = body;
     this.name = "PixelLabError";
   }
-  status;
   body;
 };
 var PixelLabClient = class {
@@ -877,10 +970,11 @@ function measureBalanceChange(before, after) {
   };
 }
 var DEFAULT_RATE_LIMIT = { spacingMs: 2500, maxInFlight: 8 };
-var UnsupportedCapabilityError = class extends Error {
+var UnsupportedCapabilityError = class extends PixelKilnError {
   constructor(providerId, capability) {
     super(
-      `Provider "${providerId}" does not support ${capability}. That command is unavailable with this backend.`
+      `Provider "${providerId}" does not support ${capability}. That command is unavailable with this backend.`,
+      "capability"
     );
     this.name = "UnsupportedCapabilityError";
   }
@@ -1705,7 +1799,7 @@ var RetroDiffusionClient = class {
   /** Result URLs are signed; no token header, and the same retry policy as the API. */
   async download(url) {
     const response = await this.request(url);
-    if (!response.ok) throw new Error(`Retro Diffusion download failed (${response.status})`);
+    if (!response.ok) throw new ProviderError("retrodiffusion", `Retro Diffusion download failed (${response.status})`, { status: response.status });
     return Buffer.from(await response.arrayBuffer());
   }
   async call(path32, init = {}) {
@@ -1728,8 +1822,10 @@ var RetroDiffusionClient = class {
     if (!response.ok) {
       const retry = response.headers.get("retry-after");
       const detail = retroError(value);
-      throw new Error(
-        `Retro Diffusion request failed (${response.status}): ${detail}` + (retry ? `; retry after ${retry}s` : "")
+      throw new ProviderError(
+        "retrodiffusion",
+        `Retro Diffusion request failed (${response.status}): ${detail}` + (retry ? `; retry after ${retry}s` : ""),
+        { status: response.status }
       );
     }
     return value;
@@ -2121,7 +2217,7 @@ var ScenarioClient = class {
       throw new Error("Scenario downloads must use HTTP or HTTPS");
     }
     const response = await this.request(parsed);
-    if (!response.ok) throw new Error(`Scenario download failed (${response.status})`);
+    if (!response.ok) throw new ProviderError("scenario", `Scenario download failed (${response.status})`, { status: response.status });
     const declared = Number(response.headers.get("content-length"));
     if (Number.isFinite(declared) && declared > MAX_DOWNLOAD_BYTES) {
       throw new Error(`Scenario download exceeds the ${MAX_DOWNLOAD_BYTES}-byte safety limit`);
@@ -2168,8 +2264,10 @@ var ScenarioClient = class {
     if (!response.ok) {
       const retry = response.headers.get("retry-after");
       const detail = redactScenarioError(value, [this.apiKey, this.apiSecret, auth]);
-      throw new Error(
-        `Scenario request failed (${response.status}): ${detail}` + (retry ? `; retry after ${retry}s` : "")
+      throw new ProviderError(
+        "scenario",
+        `Scenario request failed (${response.status}): ${detail}` + (retry ? `; retry after ${retry}s` : ""),
+        { status: response.status }
       );
     }
     return value;
@@ -2619,8 +2717,10 @@ var ComfyUIClient = class {
       value = null;
     }
     if (!response.ok) {
-      throw new Error(
-        `ComfyUI image upload failed (${response.status})` + (apiError(value) ? `: ${apiError(value)}` : "")
+      throw new ProviderError(
+        "comfyui",
+        `ComfyUI image upload failed (${response.status})` + (apiError(value) ? `: ${apiError(value)}` : ""),
+        { status: response.status }
       );
     }
     if (!isObject(value) || typeof value.name !== "string" || !value.name) {
@@ -2643,7 +2743,7 @@ var ComfyUIClient = class {
     let target = source;
     if (source.startsWith("comfyui://")) target = this.viewUrl(parseSource(source));
     const response = await this.request(target);
-    if (!response.ok) throw new Error(`ComfyUI download failed (${response.status})`);
+    if (!response.ok) throw new ProviderError("comfyui", `ComfyUI download failed (${response.status})`, { status: response.status });
     return Buffer.from(await response.arrayBuffer());
   }
   endpoint(route) {
@@ -2668,8 +2768,10 @@ var ComfyUIClient = class {
     }
     if (!response.ok) {
       const detail = apiError(value);
-      throw new Error(
-        `ComfyUI request failed (${response.status}) at ${url.pathname}` + (detail ? `: ${detail}` : "")
+      throw new ProviderError(
+        "comfyui",
+        `ComfyUI request failed (${response.status}) at ${url.pathname}` + (detail ? `: ${detail}` : ""),
+        { status: response.status }
       );
     }
     return value;
@@ -3659,9 +3761,10 @@ async function loadLock(lockPath) {
   try {
     return parseLock(JSON.parse(await readFile2(lockPath, "utf8")));
   } catch (err) {
-    throw new Error(
+    throw new ProjectError(
       `Lockfile at ${lockPath} is malformed:
-${err instanceof Error ? err.message : String(err)}`
+${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
     );
   }
 }
@@ -3695,8 +3798,9 @@ async function writeLockWhileHeld(file, lock) {
     try {
       disk = parseLock(JSON.parse(await readFile2(file, "utf8")));
     } catch (err) {
-      throw new Error(
-        `Refusing to overwrite malformed lockfile at ${file}: ${err instanceof Error ? err.message : String(err)}`
+      throw new ProjectError(
+        `Refusing to overwrite malformed lockfile at ${file}: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
       );
     }
   }
@@ -3952,18 +4056,18 @@ function resolveSpecOutputs(spec, lock, manifestDir) {
 // src/manifest.ts
 async function loadManifest(manifestPath) {
   const abs = path5.resolve(manifestPath);
-  if (!existsSync4(abs)) throw new Error(`No manifest at ${abs}`);
+  if (!existsSync4(abs)) throw new ProjectError(`No manifest at ${abs}`);
   const input = ManifestInputSchema.safeParse(JSON.parse(await readFile3(abs, "utf8")));
   if (!input.success) {
     const issues = formatManifestIssues(input.error.issues);
-    throw new Error(`Manifest at ${abs} is invalid:
+    throw new ProjectError(`Manifest at ${abs} is invalid:
 ${issues}`);
   }
   let styles;
   try {
     styles = resolveStyleInheritance(input.data.styles);
   } catch (error) {
-    throw new Error(
+    throw new ProjectError(
       `Manifest at ${abs} is invalid:
   ${error instanceof Error ? error.message : String(error)}`
     );
@@ -3971,7 +4075,7 @@ ${issues}`);
   const parsed = ManifestSchema.safeParse({ ...input.data, styles });
   if (!parsed.success) {
     const issues = formatManifestIssues(parsed.error.issues);
-    throw new Error(`Manifest at ${abs} is invalid:
+    throw new ProjectError(`Manifest at ${abs} is invalid:
 ${issues}`);
   }
   const styleIds = new Set(Object.keys(parsed.data.styles));
@@ -4021,7 +4125,7 @@ ${issues}`);
   };
   for (const assetId of Object.keys(parsed.data.assets)) visitRevision(assetId, []);
   if (unknownReferences.length) {
-    throw new Error(`Manifest at ${abs} is invalid:
+    throw new ProjectError(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
   return { manifest: parsed.data, root: path5.dirname(abs), path: abs };
@@ -4100,14 +4204,14 @@ async function resolveSpecs(loaded, filter) {
   );
   for (const unknownStyle of filter?.styles ?? []) {
     if (!manifest.styles[unknownStyle]) {
-      throw new Error(
+      throw new UsageError(
         `Unknown style "${unknownStyle}". Defined: ${Object.keys(manifest.styles).join(", ") || "(none)"}`
       );
     }
   }
   for (const unknownAsset of filter?.assets ?? []) {
     if (!manifest.assets[unknownAsset]) {
-      throw new Error(`Unknown asset "${unknownAsset}".`);
+      throw new UsageError(`Unknown asset "${unknownAsset}".`);
     }
   }
   const requestedAssetIds = new Set(filter?.assets?.length ? filter.assets : Object.keys(manifest.assets));
@@ -4219,6 +4323,7 @@ async function resolveSpecs(loaded, filter) {
         detail: style.detail,
         seed: style.seed,
         palette: style.palette,
+        enforcePalette: style.enforcePalette,
         noBackground: style.noBackground,
         tileSize: generator === "tiles" ? tileSize : void 0,
         tileType: generator === "tiles" ? style.tileType : void 0,
@@ -4423,7 +4528,7 @@ function imageMetadata(buf) {
 }
 
 // src/project.ts
-import path13 from "path";
+import path12 from "path";
 
 // src/env.ts
 import { readFileSync as readFileSync2, existsSync as existsSync5 } from "fs";
@@ -4470,17 +4575,17 @@ function parseEnv(contents) {
 }
 
 // src/pipeline/plan.ts
-import { existsSync as existsSync9 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync8 } from "fs";
+import path11 from "path";
 
 // src/pipeline/quality-profile.ts
-import { existsSync as existsSync7 } from "fs";
-import path10 from "path";
+import { existsSync as existsSync6 } from "fs";
+import path9 from "path";
 
 // src/pipeline/refine.ts
-import path9 from "path";
+import path8 from "path";
 import { execFile } from "child_process";
-import { mkdtemp, readFile as readFile6, rm as rm3 } from "fs/promises";
+import { mkdtemp, readFile as readFile5, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
 import { promisify } from "util";
 
@@ -4718,10 +4823,11 @@ async function writeManagedArtifactBundle(manifestPath, outputs, provenance, opt
       if (!expected || digest(current) !== expected) conflicts.push(destination);
     }
     if (conflicts.length) {
-      throw new Error(
+      throw new OverwriteRefusedError(
         `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.`
+Pass { force: true } (CLI: --force) to take ownership and replace the complete bundle.`,
+        conflicts
       );
     }
   }
@@ -4940,10 +5046,19 @@ async function writeArtifactBundle(files, options = {}) {
   };
 }
 
-// src/pipeline/audit.ts
-import { readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import path8 from "path";
+// src/palette.ts
+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")}`;
+    if (!colors.has(hex2)) colors.set(hex2, { hex: hex2, ...rgb });
+  }
+  if (colors.size < 2 || colors.size > 256) {
+    throw new Error(`A palette must contain 2\u2013256 unique colors; got ${colors.size}.`);
+  }
+  return [...colors.values()];
+}
 function colorDistance(a, b) {
   const rmean = (a.r + b.r) / 2;
   const dr = a.r - b.r;
@@ -4953,146 +5068,45 @@ function colorDistance(a, b) {
     (512 + rmean) * dr * dr / 256 + 4 * dg * dg + (767 - rmean) * db * db / 256
   );
 }
-function paletteDistance(asset, reference) {
-  if (!asset.length || !reference.length) return 0;
-  let total = 0;
-  let weight = 0;
-  for (const color of asset) {
-    let nearest = Infinity;
-    for (const ref of reference) nearest = Math.min(nearest, colorDistance(color, ref));
-    total += nearest * color.weight;
-    weight += color.weight;
-  }
-  return weight === 0 ? 0 : total / weight;
-}
-function mergePalettes(palettes, topN = 24) {
-  const totals = /* @__PURE__ */ new Map();
-  for (const palette of palettes) {
-    for (const color of palette) {
-      const key = `${color.r},${color.g},${color.b}`;
-      const existing = totals.get(key);
-      if (existing) existing.weight += color.weight;
-      else totals.set(key, { ...color });
+function quantize(png, palette) {
+  const colors = normalizePalette(palette);
+  const pixels = Buffer.from(png.pixels);
+  const nearestOf = /* @__PURE__ */ new Map();
+  let changed = 0;
+  for (let i = 0; i < pixels.length; i += 4) {
+    const alpha = pixels[i + 3];
+    if (alpha === 0) {
+      if (pixels[i] || pixels[i + 1] || pixels[i + 2]) changed++;
+      pixels[i] = 0;
+      pixels[i + 1] = 0;
+      pixels[i + 2] = 0;
+      continue;
     }
-  }
-  const merged = [...totals.values()].sort((a, b) => b.weight - a.weight).slice(0, topN);
-  const sum = merged.reduce((s, c) => s + c.weight, 0) || 1;
-  return merged.map((c) => ({ ...c, weight: c.weight / sum }));
-}
-async function auditStyle(loaded, specs, styleId, lock) {
-  const style = loaded.manifest.styles[styleId];
-  if (!style) throw new Error(`Unknown style "${styleId}"`);
-  const mine = specs.filter((s) => s.styleId === styleId);
-  const assets = [];
-  const missing = [];
-  const unreadable = [];
-  for (const spec of mine) {
-    for (const output of resolveSpecOutputs(spec, lock, loaded.root)) {
-      if (!existsSync6(output.absolutePath)) {
-        missing.push(output.id);
-        continue;
-      }
-      try {
-        const png = decodePng(await readFile5(output.absolutePath));
-        const palette = extractPalette(png, 12);
-        assets.push({
-          assetId: spec.assetId,
-          ...output.role ? { outputRole: output.role } : {},
-          id: output.id,
-          file: output.absolutePath,
-          width: png.width,
-          height: png.height,
-          paletteDistance: 0,
-          // filled once the reference is known
-          transparency: transparencyRatio(png),
-          colorCount: countColors(png),
-          palette
-        });
-      } catch (err) {
-        unreadable.push(`${output.id}: ${err instanceof Error ? err.message : String(err)}`);
+    const key = pixels[i] << 16 | pixels[i + 1] << 8 | pixels[i + 2];
+    let nearest = nearestOf.get(key);
+    if (!nearest) {
+      const pixel = { r: pixels[i], g: pixels[i + 1], b: pixels[i + 2] };
+      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;
+        }
       }
+      nearestOf.set(key, nearest);
     }
+    if (pixels[i] !== nearest.r || pixels[i + 1] !== nearest.g || pixels[i + 2] !== nearest.b) changed++;
+    pixels[i] = nearest.r;
+    pixels[i + 1] = nearest.g;
+    pixels[i + 2] = nearest.b;
   }
-  let reference = [];
-  let referenceFromStyleImages = false;
-  const refPalettes = [];
-  for (const img of style.styleImages) {
-    const abs = path8.resolve(loaded.root, img.path);
-    if (!existsSync6(abs)) continue;
-    try {
-      refPalettes.push(extractPalette(decodePng(await readFile5(abs)), 12));
-    } catch {
-    }
-  }
-  if (refPalettes.length) {
-    reference = mergePalettes(refPalettes);
-    referenceFromStyleImages = true;
-    for (const asset of assets) {
-      asset.paletteDistance = paletteDistance(asset.palette, reference);
-    }
-  } else {
-    reference = mergePalettes(assets.map((a) => a.palette));
-    for (const asset of assets) {
-      const others = assets.filter((a) => a !== asset).map((a) => a.palette);
-      asset.paletteDistance = others.length ? paletteDistance(asset.palette, mergePalettes(others)) : 0;
-    }
-  }
-  assets.sort((a, b) => b.paletteDistance - a.paletteDistance);
-  return { styleId, referenceFromStyleImages, reference, assets, missing, unreadable };
-}
-function countColors(png) {
-  const seen = /* @__PURE__ */ new Set();
-  for (let i = 0; i < png.pixels.length; i += 4) {
-    if (png.pixels[i + 3] < 128) continue;
-    seen.add(png.pixels[i] << 16 | png.pixels[i + 1] << 8 | png.pixels[i + 2]);
-  }
-  return seen.size;
+  return { png: { width: png.width, height: png.height, pixels }, changed };
 }
-function outliers(audit, sigma = 1.5) {
-  const n = audit.assets.length;
-  if (n < 3) return [];
-  const mean = audit.assets.reduce((s, a) => s + a.paletteDistance, 0) / n;
-  const variance = audit.assets.reduce((s, a) => s + (a.paletteDistance - mean) ** 2, 0) / n;
-  const sd = Math.sqrt(variance);
-  if (sd === 0) return [];
-  return audit.assets.filter((a) => a.paletteDistance > mean + sigma * sd);
-}
-function evaluateAudit(audit, thresholds = {}) {
-  const resolved = { ...thresholds, sigma: thresholds.sigma ?? 1.5 };
-  const relative = outliers(audit, resolved.sigma);
-  const relativeIds = new Set(relative.map((asset) => asset.id));
-  const violations = [];
-  for (const asset of audit.assets) {
-    const reasons = [];
-    if (relativeIds.has(asset.id)) {
-      reasons.push(`palette outlier beyond ${resolved.sigma} standard deviations`);
-    }
-    if (resolved.maxDistance !== void 0 && asset.paletteDistance > resolved.maxDistance) {
-      reasons.push(
-        `palette distance ${asset.paletteDistance.toFixed(1)} exceeds ${resolved.maxDistance}`
-      );
-    }
-    if (resolved.minTransparency !== void 0 && asset.transparency < resolved.minTransparency) {
-      reasons.push(
-        `transparency ${(asset.transparency * 100).toFixed(1)}% is below ${(resolved.minTransparency * 100).toFixed(1)}%`
-      );
-    }
-    if (resolved.maxColors !== void 0 && asset.colorCount > resolved.maxColors) {
-      reasons.push(`color count ${asset.colorCount} exceeds ${resolved.maxColors}`);
-    }
-    if (reasons.length) violations.push({ id: asset.id, reasons });
-  }
-  return {
-    safe: violations.length === 0 && audit.missing.length === 0 && audit.unreadable.length === 0,
-    thresholds: resolved,
-    outliers: [...relativeIds],
-    violations,
-    missing: [...audit.missing],
-    unreadable: [...audit.unreadable]
-  };
-}
-function hex(c) {
-  return `#${[c.r, c.g, c.b].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+function quantizeToPalette(png, palette) {
+  return quantize(png, palette).png;
 }
 
 // src/pipeline/refine.ts
@@ -5179,48 +5193,12 @@ function parseDetection(raw) {
     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 normalizeRefinementPalette(values) {
-  return normalizePalette(values).map((color) => color.hex);
-}
-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;
+  try {
+    return normalizePalette(values).map((color) => color.hex);
+  } catch (err) {
+    throw new Error(`A refinement palette must contain 2\u2013256 unique colors; got ${new Set(values.map((v) => v.toLowerCase())).size}.`, { cause: err });
   }
-  return { width: png.width, height: png.height, pixels };
 }
 function colorCount(png) {
   const colors = /* @__PURE__ */ new Set();
@@ -5330,16 +5308,16 @@ function sameFrameGrid(first, next) {
   return next.detection.stepX === first.detection.stepX && next.detection.stepY === first.detection.stepY && next.detection.columns === first.detection.columns && next.detection.rows === first.detection.rows && phaseMatches(next.detection.phaseX, first.detection.phaseX, first.detection.stepX) && phaseMatches(next.detection.phaseY, first.detection.phaseY, first.detection.stepY) && next.audit.width === first.audit.width && next.audit.height === first.audit.height && next.sourceWidth === first.sourceWidth && next.sourceHeight === first.sourceHeight;
 }
 async function refineAsset(options) {
-  const source = path9.resolve(options.source);
-  const output = path9.resolve(options.output);
+  const source = path8.resolve(options.source);
+  const output = path8.resolve(options.output);
   if (source === output) throw new Error("Refinement source and output must be different files.");
-  const record = path9.resolve(qualityRecordPath(output));
+  const record = path8.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 readFile6(source));
+    sourcePng = decodePng(await readFile5(source));
   } catch (error) {
     throw new Error(`Cannot read refinement source ${source}: ${message2(error)}`, { cause: error });
   }
@@ -5356,8 +5334,8 @@ async function refineAsset(options) {
       );
     }
   }
-  const temp = await mkdtemp(path9.join(tmpdir(), "pixelkiln-refine-"));
-  const recovered = path9.join(temp, "native.png");
+  const temp = await mkdtemp(path8.join(tmpdir(), "pixelkiln-refine-"));
+  const recovered = path8.join(temp, "native.png");
   const fixerCommand = compatibilityCommand ?? options.fixerPython ?? process.env.PIXELKILN_PIXEL_FIXER_PYTHON ?? "python3";
   const args = compatibilityCommand ? [...options.fixerArgsPrefix ?? [], source, "--extract", recovered] : ["-c", PYTHON_FIXER_BRIDGE, source, recovered];
   try {
@@ -5378,7 +5356,7 @@ async function refineAsset(options) {
       );
     }
     const detection = parseDetection(firstJsonObject(stdout));
-    const native = decodePng(await readFile6(recovered));
+    const native = decodePng(await readFile5(recovered));
     const quantized = quantizeToPalette(native, palette);
     const png = encodeRgbaPng(quantized.width, quantized.height, quantized.pixels);
     const audit = auditRefinement(
@@ -5442,18 +5420,18 @@ async function refineFrameSet(options) {
   if (roles.some((role) => !role.trim()) || new Set(roles).size !== roles.length) {
     throw new Error("Frame-set roles must be non-empty and unique.");
   }
-  const output = path9.resolve(options.output);
-  const record = path9.resolve(qualityRecordPath(output));
+  const output = path8.resolve(options.output);
+  const record = path8.resolve(qualityRecordPath(output));
   const palette = normalizeRefinementPalette(options.palette);
   const finalOutputs = options.sources.map((source, index) => qualityFrameOutputPath(output, source.role, index));
   if (new Set(finalOutputs).size !== finalOutputs.length) {
     throw new Error("Frame-set roles resolve to duplicate output filenames.");
   }
-  const sourceSet = new Set(options.sources.map((source) => path9.resolve(source.path)));
+  const sourceSet = new Set(options.sources.map((source) => path8.resolve(source.path)));
   if (finalOutputs.some((file) => sourceSet.has(file))) {
     throw new Error("Frame-set refinement sources and outputs must be different files.");
   }
-  const temp = await mkdtemp(path9.join(tmpdir(), "pixelkiln-refine-frames-"));
+  const temp = await mkdtemp(path8.join(tmpdir(), "pixelkiln-refine-frames-"));
   try {
     const frames = [];
     const outputs = [];
@@ -5461,8 +5439,8 @@ async function refineFrameSet(options) {
     const sourcePaths = [];
     let firstOptions = null;
     for (const [index, sourceEntry] of options.sources.entries()) {
-      const source = path9.resolve(sourceEntry.path);
-      const temporaryOutput = path9.join(temp, `${String(index).padStart(2, "0")}.png`);
+      const source = path8.resolve(sourceEntry.path);
+      const temporaryOutput = path8.join(temp, `${String(index).padStart(2, "0")}.png`);
       const refined = await refineAsset({
         source,
         output: temporaryOutput,
@@ -5494,7 +5472,7 @@ async function refineFrameSet(options) {
       });
       outputs.push({
         path: finalOutputs[index],
-        data: await readFile6(temporaryOutput)
+        data: await readFile5(temporaryOutput)
       });
     }
     const first = frames[0];
@@ -5537,7 +5515,7 @@ async function refineFrameSet(options) {
     );
     return {
       sources: sourcePaths,
-      outputs: outputs.map((item) => path9.resolve(item.path)),
+      outputs: outputs.map((item) => path8.resolve(item.path)),
       record,
       frames,
       palette,
@@ -5548,12 +5526,12 @@ async function refineFrameSet(options) {
   }
 }
 async function checkQualityRecord(recordPath) {
-  const record = path9.resolve(recordPath);
+  const record = path8.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
-  const sources = manifest.sources.map((source2) => path9.resolve(path9.dirname(record), source2.path));
-  const outputs = manifest.outputs.map((output2) => path9.resolve(path9.dirname(record), output2.path));
+  const sources = manifest.sources.map((source2) => path8.resolve(path8.dirname(record), source2.path));
+  const outputs = manifest.outputs.map((output2) => path8.resolve(path8.dirname(record), output2.path));
   const source = sources[0] ?? "";
   const output = outputs[0] ?? "";
   const expectedCount = options.frameSet?.count ?? 1;
@@ -5586,7 +5564,7 @@ async function checkQualityRecord(recordPath) {
 async function approveQualityRecord(recordPath, approval) {
   const reviewer = approval.reviewer.trim();
   if (!reviewer) throw new Error("A human reviewer name is required.");
-  const record = path9.resolve(recordPath);
+  const record = path8.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
@@ -5607,14 +5585,14 @@ async function approveQualityRecord(recordPath, approval) {
       `A refinement record must contain exactly ${expectedCount} source(s) and output(s).`
     );
   }
-  const root = path9.dirname(record);
+  const root = path8.dirname(record);
   const outputs = await Promise.all(manifest.outputs.map(async (entry) => {
-    const outputPath = path9.resolve(root, entry.path);
-    return { path: outputPath, data: await readFile6(outputPath) };
+    const outputPath = path8.resolve(root, entry.path);
+    return { path: outputPath, data: await readFile5(outputPath) };
   }));
   const sources = manifest.sources.map((source) => ({
     ...source,
-    path: path9.resolve(root, source.path)
+    path: path8.resolve(root, source.path)
   }));
   const approved = {
     ...options,
@@ -5646,8 +5624,8 @@ async function qualitySource(spec, lock) {
     if (spec.generator === "frames") {
       return { items: null, reason: "frame-set quality requires ordered downloaded provider outputs" };
     }
-    const source = path10.resolve(spec.root, spec.source);
-    return existsSync7(source) ? { items: [{ role: "source", path: source }] } : { items: null, reason: `declared source is missing: ${spec.source}` };
+    const source = path9.resolve(spec.root, spec.source);
+    return existsSync6(source) ? { items: [{ role: "source", path: source }] } : { items: null, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
   if (!entry) return { items: null, reason: "raw provider output is not in the lockfile" };
@@ -5676,7 +5654,7 @@ async function qualitySource(spec, lock) {
     }
     if (role) roles.add(role);
     const source = currentEntryOutputPath(entry, spec, index);
-    if (!existsSync7(source)) return { items: null, reason: `raw provider output is missing: ${source}` };
+    if (!existsSync6(source)) return { items: null, reason: `raw provider output is missing: ${source}` };
     if (await sha256File(source) !== output.sha256) {
       return { items: null, reason: "raw provider output was modified after download" };
     }
@@ -5695,7 +5673,7 @@ async function inspectQualityProfile(spec, lock) {
   }
   const sourcePaths = source.items.map((item) => item.path);
   const expectedOutputs = spec.generator === "frames" ? source.items.map((item, index) => qualityFrameOutputPath(output, item.role, index)) : [output];
-  if (!existsSync7(record)) {
+  if (!existsSync6(record)) {
     return {
       key,
       state: "needs-refinement",
@@ -5713,7 +5691,7 @@ async function inspectQualityProfile(spec, lock) {
     const expectedRevision = spec.quality.fixerRevision ?? PIXEL_ART_FIXER_REVISION;
     const expectedTransparency = spec.quality.minTransparency ?? null;
     const expectedFrameSet = spec.generator === "frames" ? { fps: spec.quality.fps ?? 12, count: source.items.length, roles: source.items.map((item) => item.role) } : null;
-    const contractChanged = JSON.stringify(check.sources.map((item) => path10.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => path10.resolve(item))) || JSON.stringify(check.outputs.map((item) => path10.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => path10.resolve(item))) || JSON.stringify(check.options.palette.colors) !== JSON.stringify(expectedPalette) || check.options.nativeGrid.revision !== expectedRevision || check.options.audit.thresholds.minGridConfidence !== spec.quality.minGridConfidence || check.options.audit.thresholds.minTransparency !== expectedTransparency || (expectedFrameSet ? !check.options.frameSet || check.options.frameSet.fps !== expectedFrameSet.fps || check.options.frameSet.count !== expectedFrameSet.count || JSON.stringify(check.options.frameSet.roles) !== JSON.stringify(expectedFrameSet.roles) : check.options.frameSet !== void 0);
+    const contractChanged = JSON.stringify(check.sources.map((item) => path9.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => path9.resolve(item))) || JSON.stringify(check.outputs.map((item) => path9.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => path9.resolve(item))) || JSON.stringify(check.options.palette.colors) !== JSON.stringify(expectedPalette) || check.options.nativeGrid.revision !== expectedRevision || check.options.audit.thresholds.minGridConfidence !== spec.quality.minGridConfidence || check.options.audit.thresholds.minTransparency !== expectedTransparency || (expectedFrameSet ? !check.options.frameSet || check.options.frameSet.fps !== expectedFrameSet.fps || check.options.frameSet.count !== expectedFrameSet.count || JSON.stringify(check.options.frameSet.roles) !== JSON.stringify(expectedFrameSet.roles) : check.options.frameSet !== void 0);
     if (contractChanged) {
       return {
         key,
@@ -5875,9 +5853,38 @@ async function requireApprovedQualitySources(specs, lock, assetIds, outputRoles)
   return sources;
 }
 
+// src/pipeline/postprocess.ts
+function postprocessFor(spec) {
+  if (!spec.enforcePalette || spec.palette.length < 2) return void 0;
+  return {
+    palette: {
+      colors: normalizePalette(spec.palette).map((color) => color.hex),
+      dither: "none",
+      distance: "redmean"
+    }
+  };
+}
+function samePostprocess(a, b) {
+  const pa = a?.palette;
+  const pb = b?.palette;
+  if (!pa && !pb) return true;
+  if (!pa || !pb) return false;
+  return pa.dither === pb.dither && pa.distance === pb.distance && pa.colors.length === pb.colors.length && pa.colors.every((color, i) => color === pb.colors[i]);
+}
+function postprocessCurrent(entry, spec) {
+  return samePostprocess(entry.postprocess, postprocessFor(spec));
+}
+function applyPostprocess(bytes, mediaType, record) {
+  if (!record?.palette || mediaType !== MediaType.PNG) return { bytes, changed: false };
+  const png = decodePng(bytes);
+  const { png: snapped, changed } = quantize(png, record.palette.colors);
+  if (!changed) return { bytes, changed: false };
+  return { bytes: encodeRgbaPng(snapped.width, snapped.height, snapped.pixels), changed: true };
+}
+
 // src/pipeline/revision.ts
-import { existsSync as existsSync8 } from "fs";
-import path11 from "path";
+import { existsSync as existsSync7 } from "fs";
+import path10 from "path";
 async function inspectRevisionReadiness(spec, lock) {
   if (!spec.revision) return null;
   return inspectRevision(spec, lock, /* @__PURE__ */ new Set());
@@ -5892,14 +5899,14 @@ async function inspectRevision(spec, lock, seen) {
       reason: `revision source ${spec.styleId}/${revision.sourceAssetId} is not ready: ${dependency.reason}`
     };
   }
-  if (!revision.sourceSha256 || !existsSync8(revision.sourceFile)) {
+  if (!revision.sourceSha256 || !existsSync7(revision.sourceFile)) {
     return { ready: false, reason: `revision source is missing: ${revision.sourceFile}` };
   }
   if (await sha256File(revision.sourceFile) !== revision.sourceSha256) {
     return { ready: false, reason: "revision source changed after the manifest was resolved" };
   }
   if (revision.maskFile) {
-    if (!revision.maskSha256 || !existsSync8(revision.maskFile)) {
+    if (!revision.maskSha256 || !existsSync7(revision.maskFile)) {
       return { ready: false, reason: `revision mask is missing: ${revision.maskFile}` };
     }
     if (await sha256File(revision.maskFile) !== revision.maskSha256) {
@@ -5929,8 +5936,8 @@ async function inspectParent(spec, lock, seen) {
     };
   }
   if (spec.source) {
-    const source = path11.resolve(spec.root, spec.source);
-    return existsSync8(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
+    const source = path10.resolve(spec.root, spec.source);
+    return existsSync7(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[key];
   if (!entry) return { ready: false, reason: "parent is not in the lockfile" };
@@ -5944,7 +5951,7 @@ async function inspectParent(spec, lock, seen) {
   for (let index = 0; index < entry.outputs.length; index++) {
     const output = entry.outputs[index];
     const file = currentEntryOutputPath(entry, spec, index);
-    if (!existsSync8(file)) return { ready: false, reason: `parent output is missing: ${file}` };
+    if (!existsSync7(file)) return { ready: false, reason: `parent output is missing: ${file}` };
     if (await sha256File(file) !== output.sha256) {
       return { ready: false, reason: `parent output was modified: ${file}` };
     }
@@ -5973,7 +5980,7 @@ function resumeActions(specs, lock) {
     const entry = lock.entries[key];
     if (!entry || entry.specHash !== spec.specHash) continue;
     if (entry.submissionComplete === false) continue;
-    const command = resumeCommandForStatus(entry.status);
+    const command = resumeCommandForStatus(entry.status) ?? (entry.status === "downloaded" && entry.outputs.length && !postprocessCurrent(entry, spec) ? "fetch" : null);
     if (!command) continue;
     if (command === "poll" && !entry.jobId) continue;
     if (command === "pick" && !entry.reviewObjectId) continue;
@@ -5999,7 +6006,7 @@ async function buildPlan(specs, lock, opts = {}) {
       state = "missing";
       reason = "--force";
     } else if (!entry && spec.source && spec.generator !== "frames") {
-      if (existsSync9(path12.resolve(spec.root, spec.source))) {
+      if (existsSync8(path11.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -6007,7 +6014,7 @@ async function buildPlan(specs, lock, opts = {}) {
         reason = `declared source is missing: ${spec.source}`;
       }
     } else if (!entry) {
-      if (existsSync9(spec.outFile)) {
+      if (existsSync8(spec.outFile)) {
         state = "untracked";
         reason = "file on disk, no provenance recorded";
       } else {
@@ -6039,12 +6046,15 @@ async function buildPlan(specs, lock, opts = {}) {
     } else if (entry.status !== "downloaded") {
       state = "in-flight";
       reason = `awaiting ${entry.status}`;
-    } else if (entry.outputs.length === 0 || entry.outputs.some((_output, index) => !existsSync9(currentEntryOutputPath(entry, spec, index)))) {
+    } else if (entry.outputs.length === 0 || entry.outputs.some((_output, index) => !existsSync8(currentEntryOutputPath(entry, spec, index)))) {
       state = "orphaned";
-      reason = entry.outputs.length === 0 ? "no recorded output files" : `missing on disk: ${entry.outputs.filter((_output, index) => !existsSync9(currentEntryOutputPath(entry, spec, index))).map((o) => o.role ?? "asset").join(", ")}`;
+      reason = entry.outputs.length === 0 ? "no recorded output files" : `missing on disk: ${entry.outputs.filter((_output, index) => !existsSync8(currentEntryOutputPath(entry, spec, index))).map((o) => o.role ?? "asset").join(", ")}`;
     } else if (await anyOutputModified(entry, spec)) {
       state = "orphaned";
       reason = "output modified since download";
+    } else if (!postprocessCurrent(entry, spec)) {
+      state = "recoverable";
+      reason = spec.enforcePalette ? "palette enforcement turned on; run pixelkiln fetch to snap the file (no generation cost)" : "palette enforcement turned off; run pixelkiln fetch to restore the provider's bytes (no generation cost)";
     } else {
       state = "ok";
       reason = "up to date";
@@ -6107,13 +6117,13 @@ function summarize(plan) {
 
 // src/project.ts
 async function openProject(manifestPath = "pixelkiln.manifest.json", opts = {}) {
-  const absolute = path13.resolve(manifestPath);
-  const root = path13.dirname(absolute);
+  const absolute = path12.resolve(manifestPath);
+  const root = path12.dirname(absolute);
   if (opts.env !== false) {
     loadEnvFiles(root);
-    if (path13.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
+    if (path12.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
   }
-  const lockPath = path13.resolve(opts.lockPath ?? path13.join(root, "pixelkiln.lock.json"));
+  const lockPath = path12.resolve(opts.lockPath ?? path12.join(root, "pixelkiln.lock.json"));
   const loaded = await loadManifest(absolute);
   const specs = await resolveSpecs(loaded, { styles: opts.styles ?? [], assets: opts.assets ?? [] });
   const lock = await loadLock(lockPath);
@@ -6180,9 +6190,9 @@ function shouldPersistSourceUrl(value) {
 }
 
 // src/recipes.ts
-import path14 from "path";
-import { existsSync as existsSync10 } from "fs";
-import { readdir, readFile as readFile7 } from "fs/promises";
+import path13 from "path";
+import { existsSync as existsSync9 } from "fs";
+import { readdir, readFile as readFile6 } from "fs/promises";
 import { fileURLToPath } from "url";
 import { z as z3 } from "zod";
 var SHA256_RE = /^[0-9a-f]{64}$/;
@@ -6191,7 +6201,7 @@ var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
 var PortablePathSchema = z3.string().min(1).refine((value) => {
-  if (value.includes("\\") || path14.posix.isAbsolute(value)) return false;
+  if (value.includes("\\") || path13.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
@@ -6367,10 +6377,10 @@ function message3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path14.resolve(recipePath);
+  const absolute = path13.resolve(recipePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile7(absolute, "utf8"));
+    raw = JSON.parse(await readFile6(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read recipe ${absolute}: ${message3(error)}`, { cause: error });
   }
@@ -6381,13 +6391,13 @@ async function readRecipeFile(recipePath, bundled) {
 ` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
     );
   }
-  return { recipe: parsed.data, path: absolute, dir: path14.dirname(absolute), bundled };
+  return { recipe: parsed.data, authored: raw, path: absolute, dir: path13.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
-  if (!existsSync10(root)) return [];
+  if (!existsSync9(root)) return [];
   const out = [];
   for (const entry of await readdir(root, { withFileTypes: true })) {
-    const resolved = path14.join(root, entry.name);
+    const resolved = path13.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -6398,7 +6408,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path14.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path13.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)
@@ -6421,9 +6431,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path14.resolve(target);
-  if (existsSync10(local)) {
-    const recipePath = path14.basename(local) === RECIPE_FILE ? local : path14.join(local, RECIPE_FILE);
+  const local = path13.resolve(target);
+  if (existsSync9(local)) {
+    const recipePath = path13.basename(local) === RECIPE_FILE ? local : path13.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -6437,8 +6447,8 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path14.resolve(root, ...file.path.split("/"));
-  if (!existsSync10(absolute)) {
+  const absolute = path13.resolve(root, ...file.path.split("/"));
+  if (!existsSync9(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
   const actualSha256 = await sha256File(absolute);
@@ -6451,9 +6461,9 @@ async function verifyFile(root, file) {
 }
 async function verifyRecipe(target, options = {}) {
   const loaded = await resolveRecipe(target, options.bundledRoot);
-  const actualIntegrity = recipeDigest(loaded.recipe);
+  const actualIntegrity = recipeDigest(loaded.authored);
   const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
-  const modelRoot = options.modelRoot ? path14.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path13.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -6487,7 +6497,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path14.relative(cwd, destination).split(path14.sep).join("/") || ".";
+  const portableDir = path13.relative(cwd, destination).split(path13.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -6499,28 +6509,29 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path14.resolve(options.cwd ?? process.cwd());
+  const cwd = path13.resolve(options.cwd ?? process.cwd());
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const verification = await verifyRecipe(loaded.path);
   if (!verification.ok) {
     throw new Error(`Recipe ${loaded.recipe.id}@${loaded.recipe.version} failed integrity verification.`);
   }
-  const destination = options.out ? path14.resolve(cwd, options.out) : path14.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path13.resolve(cwd, options.out) : path13.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
   const sources = [
     { path: RECIPE_FILE, source: loaded.path },
-    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path14.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path13.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path14.join(destination, ...file.path.split("/")),
-    data: await readFile7(file.source)
+    path: path13.join(destination, ...file.path.split("/")),
+    data: await readFile6(file.source)
   })));
   if (!options.force) {
     for (const file of files) {
-      if (!existsSync10(file.path)) continue;
-      const current = await readFile7(file.path);
+      if (!existsSync9(file.path)) continue;
+      const current = await readFile6(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.`
+        throw new OverwriteRefusedError(
+          `Recipe destination has local changes: ${file.path}. Choose another --out or pass --force to replace declared recipe files.`,
+          [file.path]
         );
       }
     }
@@ -6539,6 +6550,152 @@ async function installRecipe(target, options = {}) {
   };
 }
 
+// src/pipeline/audit.ts
+import { readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import path14 from "path";
+function paletteDistance(asset, reference) {
+  if (!asset.length || !reference.length) return 0;
+  let total = 0;
+  let weight = 0;
+  for (const color of asset) {
+    let nearest = Infinity;
+    for (const ref of reference) nearest = Math.min(nearest, colorDistance(color, ref));
+    total += nearest * color.weight;
+    weight += color.weight;
+  }
+  return weight === 0 ? 0 : total / weight;
+}
+function mergePalettes(palettes, topN = 24) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const palette of palettes) {
+    for (const color of palette) {
+      const key = `${color.r},${color.g},${color.b}`;
+      const existing = totals.get(key);
+      if (existing) existing.weight += color.weight;
+      else totals.set(key, { ...color });
+    }
+  }
+  const merged = [...totals.values()].sort((a, b) => b.weight - a.weight).slice(0, topN);
+  const sum = merged.reduce((s, c) => s + c.weight, 0) || 1;
+  return merged.map((c) => ({ ...c, weight: c.weight / sum }));
+}
+async function auditStyle(loaded, specs, styleId, lock) {
+  const style = loaded.manifest.styles[styleId];
+  if (!style) throw new Error(`Unknown style "${styleId}"`);
+  const mine = specs.filter((s) => s.styleId === styleId);
+  const assets = [];
+  const missing = [];
+  const unreadable = [];
+  for (const spec of mine) {
+    for (const output of resolveSpecOutputs(spec, lock, loaded.root)) {
+      if (!existsSync10(output.absolutePath)) {
+        missing.push(output.id);
+        continue;
+      }
+      try {
+        const png = decodePng(await readFile7(output.absolutePath));
+        const palette = extractPalette(png, 12);
+        assets.push({
+          assetId: spec.assetId,
+          ...output.role ? { outputRole: output.role } : {},
+          id: output.id,
+          file: output.absolutePath,
+          width: png.width,
+          height: png.height,
+          paletteDistance: 0,
+          // filled once the reference is known
+          transparency: transparencyRatio(png),
+          colorCount: countColors(png),
+          palette
+        });
+      } catch (err) {
+        unreadable.push(`${output.id}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  let reference = [];
+  let referenceFromStyleImages = false;
+  const refPalettes = [];
+  for (const img of style.styleImages) {
+    const abs = path14.resolve(loaded.root, img.path);
+    if (!existsSync10(abs)) continue;
+    try {
+      refPalettes.push(extractPalette(decodePng(await readFile7(abs)), 12));
+    } catch {
+    }
+  }
+  if (refPalettes.length) {
+    reference = mergePalettes(refPalettes);
+    referenceFromStyleImages = true;
+    for (const asset of assets) {
+      asset.paletteDistance = paletteDistance(asset.palette, reference);
+    }
+  } else {
+    reference = mergePalettes(assets.map((a) => a.palette));
+    for (const asset of assets) {
+      const others = assets.filter((a) => a !== asset).map((a) => a.palette);
+      asset.paletteDistance = others.length ? paletteDistance(asset.palette, mergePalettes(others)) : 0;
+    }
+  }
+  assets.sort((a, b) => b.paletteDistance - a.paletteDistance);
+  return { styleId, referenceFromStyleImages, reference, assets, missing, unreadable };
+}
+function countColors(png) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < png.pixels.length; i += 4) {
+    if (png.pixels[i + 3] < 128) continue;
+    seen.add(png.pixels[i] << 16 | png.pixels[i + 1] << 8 | png.pixels[i + 2]);
+  }
+  return seen.size;
+}
+function outliers(audit, sigma = 1.5) {
+  const n = audit.assets.length;
+  if (n < 3) return [];
+  const mean = audit.assets.reduce((s, a) => s + a.paletteDistance, 0) / n;
+  const variance = audit.assets.reduce((s, a) => s + (a.paletteDistance - mean) ** 2, 0) / n;
+  const sd = Math.sqrt(variance);
+  if (sd === 0) return [];
+  return audit.assets.filter((a) => a.paletteDistance > mean + sigma * sd);
+}
+function evaluateAudit(audit, thresholds = {}) {
+  const resolved = { ...thresholds, sigma: thresholds.sigma ?? 1.5 };
+  const relative = outliers(audit, resolved.sigma);
+  const relativeIds = new Set(relative.map((asset) => asset.id));
+  const violations = [];
+  for (const asset of audit.assets) {
+    const reasons = [];
+    if (relativeIds.has(asset.id)) {
+      reasons.push(`palette outlier beyond ${resolved.sigma} standard deviations`);
+    }
+    if (resolved.maxDistance !== void 0 && asset.paletteDistance > resolved.maxDistance) {
+      reasons.push(
+        `palette distance ${asset.paletteDistance.toFixed(1)} exceeds ${resolved.maxDistance}`
+      );
+    }
+    if (resolved.minTransparency !== void 0 && asset.transparency < resolved.minTransparency) {
+      reasons.push(
+        `transparency ${(asset.transparency * 100).toFixed(1)}% is below ${(resolved.minTransparency * 100).toFixed(1)}%`
+      );
+    }
+    if (resolved.maxColors !== void 0 && asset.colorCount > resolved.maxColors) {
+      reasons.push(`color count ${asset.colorCount} exceeds ${resolved.maxColors}`);
+    }
+    if (reasons.length) violations.push({ id: asset.id, reasons });
+  }
+  return {
+    safe: violations.length === 0 && audit.missing.length === 0 && audit.unreadable.length === 0,
+    thresholds: resolved,
+    outliers: [...relativeIds],
+    violations,
+    missing: [...audit.missing],
+    unreadable: [...audit.unreadable]
+  };
+}
+function hex(c) {
+  return `#${[c.r, c.g, c.b].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+}
+
 // src/pipeline/quality-regression.ts
 import path15 from "path";
 import { existsSync as existsSync11 } from "fs";
@@ -6787,7 +6944,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   if (existsSync11(absolute) && !options.force) {
     const current = await readFile8(absolute);
     if (!current.equals(data)) {
-      throw new Error(`Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`);
+      throw new OverwriteRefusedError(
+        `Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`,
+        [absolute]
+      );
     }
   }
   const result = await writeArtifactBundle([{ path: absolute, data }]);
@@ -7008,8 +7168,14 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
     if (e.status === "selected" || e.status === "download-failed") return true;
     if (e.status !== "downloaded") return false;
     if (opts.refresh) return e.outputs.length > 0 && Boolean(e.sourceUrls?.length || e.sourceUrl);
-    if (!opts.repair) return false;
     const spec = specByKey.get(key);
+    if (spec && e.specHash === spec.specHash && e.outputs.length && !postprocessCurrent(e, spec)) {
+      return Boolean(opts.force) || e.outputs.every((output) => {
+        const file = resolveOutputPath(output.path, spec.root);
+        return existsSync13(file) && sha256(readFileSync3(file)) === output.sha256;
+      });
+    }
+    if (!opts.repair) return false;
     if (e.outputs.length === 0 || !spec) return true;
     return e.outputs.some((output) => {
       const file = resolveOutputPath(output.path, spec.root);
@@ -7048,6 +7214,8 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
       }
       const outputs = [];
       let wrote = false;
+      const wanted = postprocessFor(spec);
+      const reapply = entry.status === "downloaded" && !postprocessCurrent(entry, spec);
       try {
         for (let index = 0; index < sources.length; index++) {
           const source = sources[index];
@@ -7055,20 +7223,24 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             (o) => source.role ? o.role === source.role : !o.role && sources.length === 1
           );
           const target = recorded ? resolveOutputPath(recorded.path, spec.root) : expectedOutputPath(spec, source.role, index, sources.length, source.mediaType);
+          const expectedMediaType = source.mediaType ?? recorded?.mediaType ?? MediaType.PNG;
+          const recordedRaw = recorded?.raw ?? recorded?.sha256;
           let fresh = null;
           if (opts.refresh) {
             if (!source.url) throw new Error(`no durable source URL to refresh ${source.role ?? "asset"} from`);
             fresh = await provider.download(source.url);
-            if (recorded && sha256(fresh) === recorded.sha256) {
+            if (recorded && sha256(fresh) === recordedRaw && !reapply) {
               log(`  current ${path16.relative(process.cwd(), target)}`);
               outputs.push({ ...recorded, path: portableOutputPath(target, spec.root) });
               continue;
             }
           }
+          let raw = null;
+          let final = null;
           if (existsSync13(target)) {
             const currentHash = await sha256File(target);
             if (recorded && currentHash === recorded.sha256) {
-              if (!fresh) {
+              if (!fresh && !reapply) {
                 if (cacheDir) {
                   await cacheMedia(
                     cacheDir,
@@ -7080,7 +7252,12 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
                 outputs.push({ ...recorded, path: portableOutputPath(target, spec.root) });
                 continue;
               }
-              log(`  changed ${path16.relative(process.cwd(), target)} (upstream)`);
+              if (reapply && !fresh) {
+                if (!recorded.raw) raw = await readFile10(target);
+                log(`  reapply ${path16.relative(process.cwd(), target)}`);
+              } else {
+                log(`  changed ${path16.relative(process.cwd(), target)} (upstream)`);
+              }
             } else {
               const superseded = (entry.supersededOutputs ?? []).find(
                 (output, oldIndex, all) => currentOutputPath(output, spec, oldIndex, all.length) === target
@@ -7102,26 +7279,41 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
               );
             }
           }
-          const expectedMediaType = source.mediaType ?? recorded?.mediaType ?? MediaType.PNG;
-          let buf = fresh ?? (recorded && cacheDir ? await readCachedMedia(cacheDir, recorded.sha256, expectedMediaType) : null);
-          if (buf) {
-            log(`  cached  ${path16.relative(process.cwd(), target)}`);
-          } else {
+          if (fresh) {
+            raw = fresh;
+          } else if (!raw && recorded && cacheDir) {
+            if (!reapply) final = await readCachedMedia(cacheDir, recorded.sha256, expectedMediaType);
+            if (!final && recordedRaw) raw = await readCachedMedia(cacheDir, recordedRaw, expectedMediaType);
+            if (final || raw) log(`  cached  ${path16.relative(process.cwd(), target)}`);
+          }
+          if (!final && !raw) {
             if (!source.url) {
               throw new Error(`no source URL or cached bytes remain for ${source.role ?? "asset"}`);
             }
-            buf = await provider.download(source.url);
+            raw = await provider.download(source.url);
           }
           let mediaType;
+          const bytes = final ?? raw;
           try {
-            mediaType = validateMedia(buf, expectedMediaType);
+            mediaType = validateMedia(bytes, expectedMediaType);
           } catch (err) {
             const label = expectedMediaType === MediaType.GIF ? "GIF" : "PNG";
-            const mismatch = detectMediaType(buf) !== expectedMediaType;
+            const mismatch = detectMediaType(bytes) !== expectedMediaType;
             throw new Error(
-              `response for ${source.role ?? "asset"} was not ${mismatch ? "a" : "a valid"} ${label}` + (mismatch ? ` (${buf.length} bytes)` : `: ${err instanceof Error ? err.message : String(err)}`)
+              `response for ${source.role ?? "asset"} was not ${mismatch ? "a" : "a valid"} ${label}` + (mismatch ? ` (${bytes.length} bytes)` : `: ${err instanceof Error ? err.message : String(err)}`)
             );
           }
+          let rawHash = final ? recorded?.raw : void 0;
+          let buf = bytes;
+          if (!final) {
+            if (cacheDir) await cacheMedia(cacheDir, raw, mediaType);
+            const processed = applyPostprocess(raw, mediaType, wanted);
+            buf = processed.bytes;
+            if (processed.changed) {
+              rawHash = sha256(raw);
+              log(`  snapped ${path16.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
+            }
+          }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
           await mkdir4(path16.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
@@ -7130,7 +7322,8 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             path: portableOutputPath(target, spec.root),
             sha256: sha256(buf),
             ...source.role ? { role: source.role } : {},
-            mediaType
+            mediaType,
+            ...rawHash ? { raw: rawHash } : {}
           });
           upsert(lock, key, { outputs: mergeOutputs(entry.outputs, outputs) });
           await saveLock(lockPath, lock);
@@ -7154,7 +7347,8 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           sourceUrls: persistentSources,
           downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
           error: null,
-          supersededOutputs: []
+          supersededOutputs: [],
+          postprocess: wanted
         });
         result.downloaded++;
       } catch (err) {
@@ -7261,6 +7455,7 @@ function retireGeneration(entry, retiredAt) {
     cost: entry.cost,
     costUnit: entry.costUnit,
     provider: entry.provider,
+    postprocess: entry.postprocess,
     retiredAt
   };
 }
@@ -7273,9 +7468,13 @@ function historyAfterReplacing(previous, limit, retiredAt) {
 }
 function referencedHashes(lock) {
   const hashes = /* @__PURE__ */ new Set();
+  const add = (output) => {
+    hashes.add(output.sha256);
+    if (output.raw) hashes.add(output.raw);
+  };
   for (const entry of Object.values(lock.entries)) {
-    for (const output of entry.outputs) hashes.add(output.sha256);
-    for (const generation of entry.history ?? []) for (const output of generation.outputs) hashes.add(output.sha256);
+    for (const output of entry.outputs) add(output);
+    for (const generation of entry.history ?? []) for (const output of generation.outputs) add(output);
   }
   return hashes;
 }
@@ -7312,8 +7511,9 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
     const file = currentEntryOutputPath(entry, spec, i);
     if (!existsSync14(file)) continue;
     if (await sha256File(file) !== entry.outputs[i].sha256 && !opts.force) {
-      throw new Error(
-        `${path17.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`
+      throw new OverwriteRefusedError(
+        `${path17.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
+        [file]
       );
     }
   }
@@ -7345,6 +7545,7 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
     cost: generation.cost,
     costUnit: generation.costUnit,
     provider: generation.provider,
+    postprocess: generation.postprocess,
     history
   });
   await saveLock(lockPath, lock);
@@ -8063,7 +8264,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
   if (opts.budget != null) {
     const cost = [...estimates.values()].reduce((sum, estimate) => sum + estimate.amount, 0);
     if (cost > opts.budget) {
-      throw new Error(
+      throw new BudgetError(
         `This run would spend ${formatCost(unit, cost)} but the budget is ${formatCost(unit, opts.budget)}. Narrow it with --only/--style, or raise --budget.`
       );
     }
@@ -8701,6 +8902,7 @@ function buildManifest(name, styleId, generator, outDir, scanned) {
         promptSuffix: "",
         styleImages: [],
         palette: [],
+        enforcePalette: false,
         outDir,
         tags: [name],
         providerOptions: {}
@@ -9390,7 +9592,7 @@ var WorkspaceSchema = z6.object({
 function parseWorkspace(raw) {
   const parsed = WorkspaceSchema.safeParse(raw);
   if (parsed.success) return parsed.data;
-  throw new Error(
+  throw new ProjectError(
     `Workspace catalog is not valid v1:
 ${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
   );
@@ -9401,7 +9603,7 @@ async function loadWorkspace(workspacePath) {
   try {
     raw = JSON.parse(await readFile16(workspacePath, "utf8"));
   } catch (err) {
-    throw new Error(
+    throw new ProjectError(
       `Workspace catalog at ${workspacePath} is malformed:
 ${err instanceof Error ? err.message : String(err)}`
     );
@@ -9581,6 +9783,8 @@ var ManifestEditSchema = z7.discriminatedUnion("action", [
       promptSuffix: z7.string().optional(),
       /** `#rrggbb` values; null or empty clears the style's own palette. */
       palette: z7.array(z7.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).nullable().optional(),
+      /** Snap downloaded art to the palette; false clears the style's own value. */
+      enforcePalette: z7.boolean().optional(),
       /** Provider view name (PixelLab: low top-down, high top-down, side); empty clears. */
       view: z7.string().max(64).nullable().optional(),
       /** pixflux only; null clears the style's own value. */
@@ -9672,6 +9876,7 @@ function applyEdit(raw, edit) {
       const colors = (patch2.palette ?? []).map((color) => "#" + color.replace(/^#/, "").toLowerCase());
       setOrDelete(style, "palette", colors.length ? colors : null);
     }
+    if (patch2.enforcePalette !== void 0) setOrDelete(style, "enforcePalette", patch2.enforcePalette || null);
     if (patch2.view !== void 0) setOrDelete(style, "view", patch2.view?.trim() || null);
     if (patch2.noBackground !== void 0) setOrDelete(style, "noBackground", patch2.noBackground);
     return;
@@ -10383,6 +10588,7 @@ async function buildGallerySnapshot(opts) {
       outputs,
       quality,
       providerMetadata: entry?.providerMetadata ?? {},
+      postprocess: entry?.postprocess ?? null,
       asset,
       source: spec.source ?? null,
       edit,
@@ -10443,6 +10649,7 @@ async function buildGallerySnapshot(opts) {
       outputs,
       quality: null,
       providerMetadata: entry.providerMetadata ?? {},
+      postprocess: entry.postprocess ?? null,
       asset: null,
       source: null,
       edit: null,
@@ -10491,6 +10698,7 @@ async function buildGallerySnapshot(opts) {
       promptPrefix: style?.promptPrefix ?? "",
       promptSuffix: style?.promptSuffix ?? "",
       palette: style?.palette ?? [],
+      enforcePalette: style?.enforcePalette ?? false,
       view: style?.view ?? null,
       noBackground: style?.noBackground ?? true,
       quality: Boolean(style?.quality),
@@ -12193,6 +12401,7 @@ async function workspaceStatus(ws, dir) {
 }
 export {
   AssetSchema,
+  BudgetError,
   ComfyUIProvider,
   DEFAULT_HISTORY_LIMIT,
   DEFAULT_QUALITY_TOLERANCES,
@@ -12200,6 +12409,7 @@ export {
   DEFAULT_TIMEOUT_MS,
   EDITOR_PIN,
   EDITOR_RELEASE_BASE,
+  EXIT_CODES,
   EditorInstallError,
   FAKE_PNG,
   FakeProvider,
@@ -12224,11 +12434,16 @@ export {
   ManifestInputSchema,
   ManifestSchema,
   MediaType,
+  OverwriteRefusedError,
   PIXEL_ART_FIXER_REVISION,
   PIXEL_ART_FIXER_URL,
+  PixelKilnError,
   PixelLabClient,
   PixelLabError,
   PixelLabProvider,
+  PostprocessSchema,
+  ProjectError,
+  ProviderError,
   QualityBaselineSchema,
   QualityProfileSchema,
   QualityToleranceSchema,
@@ -12240,6 +12455,7 @@ export {
   StyleInputSchema,
   StyleSchema,
   UnsupportedCapabilityError,
+  UsageError,
   WorkspaceProjectSchema,
   WorkspaceSchema,
   adopt,
@@ -12277,7 +12493,9 @@ export {
   editorRoute,
   editorStatus,
   editorToolsRoot,
+  errorCode,
   evaluateAudit,
+  exitCodeFor,
   expectedOutputPath,
   exportTileset,
   fallbackOutputRole,