pixelkiln 0.41.0 → 0.42.0

package/dist/cli.js

@@ -68,7 +68,7 @@ function exitCodeFor(err) {
 
 // src/cli/main.ts
 import { existsSync as existsSync32 } from "fs";
-import { readFile as readFile28 } from "fs/promises";
+import { readFile as readFile29 } from "fs/promises";
 
 // src/cli/args.ts
 import path from "path";
@@ -610,7 +610,7 @@ function formatCost(unit, amount) {
 
 // src/pipeline/plan.ts
 import { existsSync as existsSync5 } from "fs";
-import path8 from "path";
+import path9 from "path";
 
 // src/hash.ts
 import { createHash } from "crypto";
@@ -618,10 +618,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path44) {
+async function sha256File(path45) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path44);
+    const stream = createReadStream(path45);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -667,6 +667,9 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
         state: spec.character.state,
         animation: spec.character.animation
       } : void 0,
+      // A mirror's bytes come from its source's recorded outputs; the plan
+      // compares those directly, so only the choice of source is identity.
+      mirror: spec.mirror ? { of: spec.mirror.sourceAssetId } : void 0,
       revision: spec.revision ? {
         mode: spec.revision.mode,
         from: spec.revision.sourceAssetId,
@@ -678,9 +681,9 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
   );
 }
 
-// src/outputs.ts
-import { existsSync as existsSync2 } from "fs";
-import path3 from "path";
+// src/pipeline/mirror.ts
+import { mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
 
 // src/lock.ts
 import { readFile, writeFile, rename, mkdir, rmdir, rm, stat } from "fs/promises";
@@ -769,6 +772,16 @@ var CHARACTER_DIRECTIONS_8 = [
   "south-west"
 ];
 var CHARACTER_DIRECTIONS_4 = ["south", "west", "east", "north"];
+var MIRRORED_DIRECTION = {
+  south: "south",
+  "south-east": "south-west",
+  east: "west",
+  "north-east": "north-west",
+  north: "north",
+  "north-west": "north-east",
+  west: "east",
+  "south-west": "south-east"
+};
 var CharacterModeSchema = z.enum(["standard", "v3", "pro"]);
 var CharacterAnimationModeSchema = z.enum(["template", "v3", "pro"]);
 var CharacterStateSchema = z.object({
@@ -1028,8 +1041,8 @@ var InheritedStyleSchema = StyleObjectSchema.partial().extend({
 }).strict();
 var StyleInputSchema = z.union([StyleSchema, InheritedStyleSchema]);
 var AssetSchema = z.object({
-  /** The subject. Style wrapping comes from the style's prefix/suffix. */
-  prompt: z.string(),
+  /** The subject. Style wrapping comes from the style's prefix/suffix. Only a `mirror` may leave it out. */
+  prompt: z.string().optional(),
   /** Subdirectory under the style's outDir. Optional. */
   category: z.string().optional(),
   /** Overrides the style default. `map` generator only. */
@@ -1087,6 +1100,19 @@ var AssetSchema = z.object({
   state: CharacterStateSchema.optional(),
   /** `character` styles: this asset is a loop of another character asset in one direction. */
   animation: CharacterAnimationSchema.optional(),
+  /**
+   * Another asset of the same style flipped left to right, made locally
+   * from that asset's downloaded files at no generation cost.
+   *
+   * The saving is in character loops, where each direction is its own
+   * generation: a walk facing west mirrored is the walk facing east, and a
+   * diagonal mirrors to the other diagonal. South and north mirror onto
+   * themselves and are refused. A single image or a frame set from any
+   * generator can be mirrored too; a tile set cannot, since its edges
+   * carry meaning. Mirroring swaps handedness, so an asymmetric character
+   * (a sword hand, a parted fringe) comes out the other way round.
+   */
+  mirror: z.string().min(1).optional(),
   /**
    * Generated output role to place in `cell` when this asset expands to
    * several files. Omit for ordinary single-output assets. A structural set
@@ -1126,7 +1152,7 @@ var AssetSchema = z.object({
       path: ["revision"]
     });
   }
-  const shapes = [asset.revision && "revision", asset.state && "state", asset.animation && "animation"].filter(Boolean);
+  const shapes = [asset.revision && "revision", asset.state && "state", asset.animation && "animation", asset.mirror && "mirror"].filter(Boolean);
   if (shapes.length > 1) {
     context.addIssue({
       code: z.ZodIssueCode.custom,
@@ -1134,6 +1160,20 @@ var AssetSchema = z.object({
       path: [shapes[1]]
     });
   }
+  if (asset.mirror && (asset.source || Object.keys(asset.sourceByStyle).length)) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "a mirror is made from another asset's files; it cannot also declare a source",
+      path: ["mirror"]
+    });
+  }
+  if (asset.prompt === void 0 && !asset.mirror) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Required",
+      path: ["prompt"]
+    });
+  }
 });
 var DEFAULT_HISTORY_LIMIT = 5;
 var HistoryLimitSchema = z.number().int().min(0).max(100);
@@ -1223,6 +1263,11 @@ var LockEntrySchema = z.object({
     maskSha256: z.string().regex(/^[0-9a-f]{64}$/).optional(),
     strength: z.number().min(0).max(1).optional()
   }).strict().nullable().default(null),
+  /** For a mirror: the asset it flips and a hash over that asset's output hashes when this was made. */
+  mirror: z.object({
+    sourceAssetId: z.string().min(1),
+    sourceSha256: z.string().regex(/^[0-9a-f]{64}$/)
+  }).strict().nullable().default(null),
   /**
    * Output hashes owned by the previous generation while its replacement is
    * pending. They authorize replacing only unchanged PixelKiln-owned files.
@@ -1922,6 +1967,8 @@ function cacheFileName(hash, mediaType = MediaType.PNG) {
 }
 
 // src/outputs.ts
+import { existsSync as existsSync2 } from "fs";
+import path3 from "path";
 function portableOutputPath(file, manifestDir) {
   const root = path3.resolve(manifestDir);
   const absolute = path3.isAbsolute(file) ? path3.normalize(file) : path3.resolve(root, file);
@@ -2047,21 +2094,219 @@ function frameSetFps(entry) {
   return null;
 }
 
+// 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;
+  const dg = a.g - b.g;
+  const db = a.b - b.b;
+  return Math.sqrt(
+    (512 + rmean) * dr * dr / 256 + 4 * dg * dg + (767 - rmean) * db * db / 256
+  );
+}
+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 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;
+  }
+  return { png: { width: png.width, height: png.height, pixels }, changed };
+}
+function quantizeToPalette(png, palette) {
+  return quantize(png, palette).png;
+}
+
+// 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/mirror.ts
+function mirrorSourceHash(source) {
+  return sha256(JSON.stringify(source.outputs.map((output) => output.sha256)));
+}
+function mirrorCurrent(entry, source) {
+  return Boolean(entry.mirror && source && entry.mirror.sourceSha256 === mirrorSourceHash(source));
+}
+function mirroredRole(role) {
+  if (role && role in MIRRORED_DIRECTION) return MIRRORED_DIRECTION[role];
+  return role;
+}
+function flipHorizontal(png) {
+  const { width, height, pixels } = decodePng(png);
+  const flipped = Buffer.alloc(pixels.length);
+  const stride = width * 4;
+  for (let y = 0; y < height; y++) {
+    const row = y * stride;
+    for (let x = 0; x < width; x++) {
+      pixels.copy(flipped, row + (width - 1 - x) * 4, row + x * 4, row + x * 4 + 4);
+    }
+  }
+  return encodeRgbaPng(width, height, flipped);
+}
+async function deriveMirror(spec, lock, lockPath, opts = {}) {
+  const log2 = opts.onProgress ?? (() => {
+  });
+  const mirror = spec.mirror;
+  const key = lockKey(spec.styleId, spec.assetId);
+  const sourceKey = lockKey(spec.styleId, mirror.sourceAssetId);
+  const source = lock.entries[sourceKey];
+  if (!source || source.status !== "downloaded" || !source.outputs.length) {
+    throw new Error(`mirror source ${sourceKey} has no downloaded outputs`);
+  }
+  const members = source.outputs.map((output, index) => ({
+    file: currentEntryOutputPath(source, mirror.sourceSpec, index),
+    role: mirroredRole(output.role)
+  }));
+  if (members.every((member) => member.role && CHARACTER_DIRECTIONS_8.includes(member.role))) {
+    members.sort((a, b) => CHARACTER_DIRECTIONS_8.indexOf(a.role) - CHARACTER_DIRECTIONS_8.indexOf(b.role));
+  }
+  const outputs = [];
+  const written = [];
+  for (const [index, member] of members.entries()) {
+    const bytes = flipHorizontal(await readFile2(member.file));
+    const target = expectedOutputPath(spec, member.role, index, members.length, MediaType.PNG);
+    await mkdir2(path4.dirname(target), { recursive: true });
+    const tmp = `${target}.pixelkiln.tmp`;
+    await writeFile2(tmp, bytes);
+    await rename2(tmp, target);
+    written.push(target);
+    outputs.push({
+      path: portableOutputPath(target, spec.root),
+      sha256: sha256(bytes),
+      ...member.role ? { role: member.role } : {},
+      mediaType: MediaType.PNG
+    });
+  }
+  const sourceMetadata = source.providerMetadata?.[source.provider] ?? {};
+  const character = spec.character;
+  const entry = upsert(lock, key, {
+    styleId: spec.styleId,
+    assetId: spec.assetId,
+    specHash: spec.specHash,
+    generator: spec.generator,
+    tileFeature: null,
+    prompt: "",
+    width: spec.width,
+    height: spec.height,
+    revision: null,
+    mirror: { sourceAssetId: mirror.sourceAssetId, sourceSha256: mirrorSourceHash(source) },
+    supersededOutputs: [],
+    jobId: null,
+    submissionComplete: void 0,
+    reviewObjectId: null,
+    objectId: null,
+    candidateIndex: null,
+    status: "downloaded",
+    error: null,
+    outputs,
+    providerMetadata: {
+      [source.provider]: {
+        ...sourceMetadata.frameSet ? { frameSet: sourceMetadata.frameSet } : {},
+        ...character ? {
+          character: {
+            kind: character.kind,
+            mirrorOf: mirror.sourceAssetId,
+            ...character.animation ? { direction: character.animation.direction } : {}
+          }
+        } : {}
+      }
+    },
+    sourceUrl: null,
+    sourceUrls: [],
+    submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    history: [],
+    cost: 0,
+    costUnit: spec.costUnit,
+    provider: source.provider,
+    postprocess: postprocessFor(spec)
+  });
+  await saveLock(lockPath, lock);
+  log2(`  mirror  ${key} \u2190 ${sourceKey} (${written.length} file${written.length === 1 ? "" : "s"} flipped, no generation cost)`);
+  return entry;
+}
+
 // src/pipeline/quality-profile.ts
 import { existsSync as existsSync3 } from "fs";
-import path6 from "path";
+import path7 from "path";
 
 // src/pipeline/refine.ts
-import path5 from "path";
+import path6 from "path";
 import { execFile } from "child_process";
-import { mkdtemp, readFile as readFile3, rm as rm3 } from "fs/promises";
+import { mkdtemp, readFile as readFile4, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
 import { promisify } from "util";
 
 // src/artifacts.ts
-import path4 from "path";
+import path5 from "path";
 import { createHash as createHash2, randomUUID } from "crypto";
-import { mkdir as mkdir2, readFile as readFile2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
 var activeTransactions = /* @__PURE__ */ new Set();
 function message(error) {
   return error instanceof Error ? error.message : String(error);
@@ -2070,7 +2315,7 @@ function digest(data) {
   return createHash2("sha256").update(data).digest("hex");
 }
 function portableRelative(from, to) {
-  return path4.relative(from, path4.resolve(to)).split(path4.sep).join("/") || ".";
+  return path5.relative(from, path5.resolve(to)).split(path5.sep).join("/") || ".";
 }
 function canonical(value) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
@@ -2120,12 +2365,12 @@ function parseArtifactManifest(absolute, data) {
   return raw;
 }
 async function readArtifactBundleManifest(manifestPath) {
-  const absolute = path4.resolve(manifestPath);
-  return parseArtifactManifest(absolute, await readFile2(absolute, "utf8"));
+  const absolute = path5.resolve(manifestPath);
+  return parseArtifactManifest(absolute, await readFile3(absolute, "utf8"));
 }
 async function readOptional(file) {
   try {
-    return await readFile2(file);
+    return await readFile3(file);
   } catch (error) {
     if (isCode(error, "ENOENT")) return null;
     throw error;
@@ -2144,8 +2389,8 @@ function processIsAlive(pid) {
   }
 }
 function validTemporaryPath(candidate, destination, type) {
-  return path4.dirname(candidate) === path4.dirname(destination) && path4.basename(candidate).startsWith(
-    `.${path4.basename(destination)}.pixelkiln-${type}-`
+  return path5.dirname(candidate) === path5.dirname(destination) && path5.basename(candidate).startsWith(
+    `.${path5.basename(destination)}.pixelkiln-${type}-`
   );
 }
 function parseTransaction(journal, data) {
@@ -2165,7 +2410,7 @@ async function removeTransactionFiles(journal) {
   await rm2(transactionMarker(journal), { force: true });
 }
 async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
-  const journal = path4.resolve(recoveryFile);
+  const journal = path5.resolve(recoveryFile);
   const bytes = await readOptional(journal);
   if (!bytes) {
     await rm2(transactionMarker(journal), { force: true });
@@ -2181,7 +2426,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
     );
   }
   for (const entry of transaction.entries) {
-    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(path4.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
+    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(path5.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.`
       );
@@ -2207,7 +2452,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
         }
         await remove2(entry.destination, errors);
         try {
-          await rename2(entry.backup, entry.destination);
+          await rename3(entry.backup, entry.destination);
         } catch (error) {
           errors.push(
             `could not restore ${entry.destination}; previous file remains at ${entry.backup}: ${message(error)}`
@@ -2227,7 +2472,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
   await removeTransactionFiles(journal);
 }
 function createArtifactBundleManifest(manifestPath, outputs, provenance) {
-  const root = path4.dirname(path4.resolve(manifestPath));
+  const root = path5.dirname(path5.resolve(manifestPath));
   const sources = provenance.sources.map((source) => ({
     ...source,
     path: portableRelative(root, source.path)
@@ -2257,11 +2502,11 @@ function withArtifactManifest(manifestPath, outputs, provenance) {
   ];
 }
 async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
-  const absoluteManifest = path4.resolve(manifestPath);
+  const absoluteManifest = path5.resolve(manifestPath);
   const recoveryFile = `${absoluteManifest}.transaction`;
   const allowedDestinations = /* @__PURE__ */ new Set([
     absoluteManifest,
-    ...outputs.map((output) => path4.resolve(output.path))
+    ...outputs.map((output) => path5.resolve(output.path))
   ]);
   await recoverArtifactTransaction(recoveryFile, allowedDestinations);
   const existingManifestBytes = await readOptional(absoluteManifest);
@@ -2279,13 +2524,13 @@ async function writeManagedArtifactBundle(manifestPath, outputs, provenance, opt
     }
   }
   if (!options.force) {
-    const root = path4.dirname(absoluteManifest);
+    const root = path5.dirname(absoluteManifest);
     const recorded = new Map(
-      previous?.outputs.map((output) => [path4.resolve(root, output.path), output.sha256]) ?? []
+      previous?.outputs.map((output) => [path5.resolve(root, output.path), output.sha256]) ?? []
     );
     const conflicts = [];
     for (const output of outputs) {
-      const destination = path4.resolve(output.path);
+      const destination = path5.resolve(output.path);
       const current = await readOptional(destination);
       if (!current || digest(current) === digest(output.data)) continue;
       const expected = recorded.get(destination);
@@ -2307,15 +2552,15 @@ Pass { force: true } (CLI: --force) to take ownership and replace the complete b
   );
 }
 async function verifyArtifactBundle(manifestPath) {
-  const absolute = path4.resolve(manifestPath);
+  const absolute = path5.resolve(manifestPath);
   const raw = await readArtifactBundleManifest(absolute);
-  const root = path4.dirname(absolute);
+  const root = path5.dirname(absolute);
   const changedSources = [];
   const changedOutputs = [];
   for (const source of raw.sources) {
     let actual = null;
     try {
-      actual = digest(await readFile2(path4.resolve(root, source.path)));
+      actual = digest(await readFile3(path5.resolve(root, source.path)));
     } catch (error) {
       if (!isCode(error, "ENOENT")) throw error;
     }
@@ -2323,7 +2568,7 @@ async function verifyArtifactBundle(manifestPath) {
   }
   for (const output of raw.outputs) {
     try {
-      if (digest(await readFile2(path4.resolve(root, output.path))) !== output.sha256) {
+      if (digest(await readFile3(path5.resolve(root, output.path))) !== output.sha256) {
         changedOutputs.push(output.path);
       }
     } catch (error) {
@@ -2362,7 +2607,7 @@ async function rollback(prepared) {
   for (const artifact of [...prepared].reverse()) {
     if (!artifact.backup || !artifact.backedUp) continue;
     try {
-      await rename2(artifact.backup, artifact.destination);
+      await rename3(artifact.backup, artifact.destination);
       artifact.backedUp = false;
     } catch (error) {
       errors.push(
@@ -2379,7 +2624,7 @@ async function writeArtifactBundle(files, options = {}) {
   if (!files.length) throw new Error("An artifact bundle must contain at least one file.");
   const normalized = files.map((file) => {
     if (!file.path.trim()) throw new Error("Artifact paths cannot be empty.");
-    return { destination: path4.resolve(file.path), data: Buffer.from(file.data) };
+    return { destination: path5.resolve(file.path), data: Buffer.from(file.data) };
   });
   const destinations = /* @__PURE__ */ new Set();
   for (const artifact of normalized) {
@@ -2395,7 +2640,7 @@ async function writeArtifactBundle(files, options = {}) {
   const unchanged = [];
   for (const artifact of normalized) {
     try {
-      const current = await readFile2(artifact.destination);
+      const current = await readFile3(artifact.destination);
       if (current.equals(artifact.data)) {
         unchanged.push(artifact.destination);
       } else {
@@ -2409,21 +2654,21 @@ async function writeArtifactBundle(files, options = {}) {
   if (!changed.length) return { changed: [], unchanged };
   const token = randomUUID();
   for (const [index, artifact] of changed.entries()) {
-    const basename = path4.basename(artifact.destination);
-    artifact.stage = path4.join(
-      path4.dirname(artifact.destination),
+    const basename = path5.basename(artifact.destination);
+    artifact.stage = path5.join(
+      path5.dirname(artifact.destination),
       `.${basename}.pixelkiln-stage-${token}-${index}`
     );
     if (artifact.existed) {
-      artifact.backup = path4.join(
-        path4.dirname(artifact.destination),
+      artifact.backup = path5.join(
+        path5.dirname(artifact.destination),
         `.${basename}.pixelkiln-backup-${token}-${index}`
       );
     }
   }
-  const journal = options.recoveryFile ? path4.resolve(options.recoveryFile) : null;
+  const journal = options.recoveryFile ? path5.resolve(options.recoveryFile) : null;
   if (journal) {
-    await mkdir2(path4.dirname(journal), { recursive: true });
+    await mkdir3(path5.dirname(journal), { recursive: true });
     const transaction = {
       format: "pixelkiln-artifact-transaction",
       version: 1,
@@ -2437,7 +2682,7 @@ async function writeArtifactBundle(files, options = {}) {
       }))
     };
     try {
-      await writeFile2(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
+      await writeFile3(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
       activeTransactions.add(journal);
     } catch (error) {
       throw new Error(
@@ -2448,9 +2693,9 @@ async function writeArtifactBundle(files, options = {}) {
   }
   try {
     for (const [index, artifact] of changed.entries()) {
-      await mkdir2(path4.dirname(artifact.destination), { recursive: true });
+      await mkdir3(path5.dirname(artifact.destination), { recursive: true });
       await options.beforeStage?.(artifact.destination, index);
-      await writeFile2(artifact.stage, artifact.data, { flag: "wx" });
+      await writeFile3(artifact.stage, artifact.data, { flag: "wx" });
     }
   } catch (error) {
     const cleanupErrors2 = await rollback(changed);
@@ -2463,17 +2708,17 @@ async function writeArtifactBundle(files, options = {}) {
   try {
     for (const artifact of changed) {
       if (!artifact.existed) continue;
-      await rename2(artifact.destination, artifact.backup);
+      await rename3(artifact.destination, artifact.backup);
       artifact.backedUp = true;
     }
     for (const [index, artifact] of changed.entries()) {
       await options.beforePromote?.(artifact.destination, index);
-      await rename2(artifact.stage, artifact.destination);
+      await rename3(artifact.stage, artifact.destination);
       artifact.stage = void 0;
       artifact.promoted = true;
     }
     if (journal) {
-      await writeFile2(transactionMarker(journal), `${token}
+      await writeFile3(transactionMarker(journal), `${token}
 `, { flag: "wx" });
       durableCommit = true;
       await options.afterCommit?.();
@@ -2515,69 +2760,6 @@ async function writeArtifactBundle(files, options = {}) {
   };
 }
 
-// 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;
-  const dg = a.g - b.g;
-  const db = a.b - b.b;
-  return Math.sqrt(
-    (512 + rmean) * dr * dr / 256 + 4 * dg * dg + (767 - rmean) * db * db / 256
-  );
-}
-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 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;
-  }
-  return { png: { width: png.width, height: png.height, pixels }, changed };
-}
-function quantizeToPalette(png, palette) {
-  return quantize(png, palette).png;
-}
-
 // src/pipeline/refine.ts
 var execFileAsync = promisify(execFile);
 var PIXEL_ART_FIXER_MIN_SIDE = 16;
@@ -2777,16 +2959,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 = path5.resolve(options.source);
-  const output = path5.resolve(options.output);
+  const source = path6.resolve(options.source);
+  const output = path6.resolve(options.output);
   if (source === output) throw new Error("Refinement source and output must be different files.");
-  const record = path5.resolve(qualityRecordPath(output));
+  const record = path6.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 readFile3(source));
+    sourcePng = decodePng(await readFile4(source));
   } catch (error) {
     throw new Error(`Cannot read refinement source ${source}: ${message2(error)}`, { cause: error });
   }
@@ -2803,8 +2985,8 @@ async function refineAsset(options) {
       );
     }
   }
-  const temp = await mkdtemp(path5.join(tmpdir(), "pixelkiln-refine-"));
-  const recovered = path5.join(temp, "native.png");
+  const temp = await mkdtemp(path6.join(tmpdir(), "pixelkiln-refine-"));
+  const recovered = path6.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 {
@@ -2825,7 +3007,7 @@ async function refineAsset(options) {
       );
     }
     const detection = parseDetection(firstJsonObject(stdout));
-    const native = decodePng(await readFile3(recovered));
+    const native = decodePng(await readFile4(recovered));
     const quantized = quantizeToPalette(native, palette);
     const png = encodeRgbaPng(quantized.width, quantized.height, quantized.pixels);
     const audit = auditRefinement(
@@ -2889,18 +3071,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 = path5.resolve(options.output);
-  const record = path5.resolve(qualityRecordPath(output));
+  const output = path6.resolve(options.output);
+  const record = path6.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) => path5.resolve(source.path)));
+  const sourceSet = new Set(options.sources.map((source) => path6.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(path5.join(tmpdir(), "pixelkiln-refine-frames-"));
+  const temp = await mkdtemp(path6.join(tmpdir(), "pixelkiln-refine-frames-"));
   try {
     const frames = [];
     const outputs = [];
@@ -2908,8 +3090,8 @@ async function refineFrameSet(options) {
     const sourcePaths = [];
     let firstOptions = null;
     for (const [index, sourceEntry] of options.sources.entries()) {
-      const source = path5.resolve(sourceEntry.path);
-      const temporaryOutput = path5.join(temp, `${String(index).padStart(2, "0")}.png`);
+      const source = path6.resolve(sourceEntry.path);
+      const temporaryOutput = path6.join(temp, `${String(index).padStart(2, "0")}.png`);
       const refined = await refineAsset({
         source,
         output: temporaryOutput,
@@ -2941,7 +3123,7 @@ async function refineFrameSet(options) {
       });
       outputs.push({
         path: finalOutputs[index],
-        data: await readFile3(temporaryOutput)
+        data: await readFile4(temporaryOutput)
       });
     }
     const first = frames[0];
@@ -2984,7 +3166,7 @@ async function refineFrameSet(options) {
     );
     return {
       sources: sourcePaths,
-      outputs: outputs.map((item) => path5.resolve(item.path)),
+      outputs: outputs.map((item) => path6.resolve(item.path)),
       record,
       frames,
       palette,
@@ -2995,12 +3177,12 @@ async function refineFrameSet(options) {
   }
 }
 async function checkQualityRecord(recordPath) {
-  const record = path5.resolve(recordPath);
+  const record = path6.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
-  const sources = manifest.sources.map((source2) => path5.resolve(path5.dirname(record), source2.path));
-  const outputs = manifest.outputs.map((output2) => path5.resolve(path5.dirname(record), output2.path));
+  const sources = manifest.sources.map((source2) => path6.resolve(path6.dirname(record), source2.path));
+  const outputs = manifest.outputs.map((output2) => path6.resolve(path6.dirname(record), output2.path));
   const source = sources[0] ?? "";
   const output = outputs[0] ?? "";
   const expectedCount = options.frameSet?.count ?? 1;
@@ -3033,7 +3215,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 = path5.resolve(recordPath);
+  const record = path6.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
@@ -3054,14 +3236,14 @@ async function approveQualityRecord(recordPath, approval) {
       `A refinement record must contain exactly ${expectedCount} source(s) and output(s).`
     );
   }
-  const root = path5.dirname(record);
+  const root = path6.dirname(record);
   const outputs = await Promise.all(manifest.outputs.map(async (entry) => {
-    const outputPath = path5.resolve(root, entry.path);
-    return { path: outputPath, data: await readFile3(outputPath) };
+    const outputPath = path6.resolve(root, entry.path);
+    return { path: outputPath, data: await readFile4(outputPath) };
   }));
   const sources = manifest.sources.map((source) => ({
     ...source,
-    path: path5.resolve(root, source.path)
+    path: path6.resolve(root, source.path)
   }));
   const approved = {
     ...options,
@@ -3093,7 +3275,7 @@ async function qualitySource(spec, lock) {
     if (spec.generator === "frames") {
       return { items: null, reason: "frame-set quality requires ordered downloaded provider outputs" };
     }
-    const source = path6.resolve(spec.root, spec.source);
+    const source = path7.resolve(spec.root, spec.source);
     return existsSync3(source) ? { items: [{ role: "source", path: source }] } : { items: null, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -3160,7 +3342,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) => path6.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => path6.resolve(item))) || JSON.stringify(check.outputs.map((item) => path6.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => path6.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) => path7.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => path7.resolve(item))) || JSON.stringify(check.outputs.map((item) => path7.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => path7.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,
@@ -3322,43 +3504,21 @@ 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 existsSync4 } from "fs";
-import path7 from "path";
+import path8 from "path";
 async function inspectRevisionReadiness(spec, lock) {
+  if (spec.mirror) return inspectMirror(spec, lock, /* @__PURE__ */ new Set());
   if (spec.character?.parentSpec) return inspectCharacterParent(spec, lock, /* @__PURE__ */ new Set());
   if (!spec.revision) return null;
   return inspectRevision(spec, lock, /* @__PURE__ */ new Set());
 }
+async function inspectMirror(spec, lock, seen) {
+  const source = spec.mirror.sourceSpec;
+  const label = `mirror source ${spec.styleId}/${spec.mirror.sourceAssetId}`;
+  const dependency = await inspectParent(source, lock, seen);
+  return dependency.ready ? { ready: true, reason: `${label} is current` } : { ready: false, reason: `${label} is not ready: ${dependency.reason}` };
+}
 async function inspectCharacterParent(spec, lock, seen) {
   const character = spec.character;
   const parentSpec = character.parentSpec;
@@ -3412,6 +3572,10 @@ async function inspectParent(spec, lock, seen) {
   if (seen.has(key)) return { ready: false, reason: `revision dependency cycle at ${key}` };
   const nextSeen = new Set(seen);
   nextSeen.add(key);
+  if (spec.mirror) {
+    const inputs = await inspectMirror(spec, lock, nextSeen);
+    if (!inputs.ready) return inputs;
+  }
   if (spec.revision) {
     const inputs = await inspectRevision(spec, lock, nextSeen);
     if (!inputs.ready) return inputs;
@@ -3428,7 +3592,7 @@ async function inspectParent(spec, lock, seen) {
     };
   }
   if (spec.source) {
-    const source = path7.resolve(spec.root, spec.source);
+    const source = path8.resolve(spec.root, spec.source);
     return existsSync4(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[key];
@@ -3498,7 +3662,7 @@ async function buildPlan(specs, lock, opts = {}) {
       state = "missing";
       reason = "--force";
     } else if (!entry && spec.source && spec.generator !== "frames") {
-      if (existsSync5(path8.resolve(spec.root, spec.source))) {
+      if (existsSync5(path9.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -3511,11 +3675,17 @@ async function buildPlan(specs, lock, opts = {}) {
         reason = "file on disk, no provenance recorded";
       } else {
         state = "missing";
-        reason = "not in lockfile";
+        reason = spec.mirror ? `not made yet; flipped from ${spec.mirror.sourceAssetId} (no generation cost)` : "not in lockfile";
       }
     } else if (entry.specHash !== spec.specHash) {
       state = "stale";
       reason = "prompt, size, or style changed";
+    } else if (spec.mirror && !mirrorCurrent(entry, lock.entries[lockKey(spec.styleId, spec.mirror.sourceAssetId)])) {
+      state = "stale";
+      reason = `mirror source ${spec.mirror.sourceAssetId} changed; flip it again (no generation cost)`;
+    } else if (spec.mirror && entry.status === "downloaded" && entry.outputs.some((_output, index) => !existsSync5(currentEntryOutputPath(entry, spec, index)))) {
+      state = "stale";
+      reason = "mirror output missing on disk; flip it again (no generation cost)";
     } else if (entry.status === "download-failed") {
       state = "recoverable";
       const force = entry.error?.includes("pass --force") ? " --force" : "";
@@ -3544,6 +3714,9 @@ async function buildPlan(specs, lock, opts = {}) {
     } else if (await anyOutputModified(entry, spec)) {
       state = "orphaned";
       reason = "output modified since download";
+    } else if (spec.mirror && !postprocessCurrent(entry, spec)) {
+      state = "stale";
+      reason = "palette enforcement changed; flip the source again once it is refreshed (no generation cost)";
     } 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)";
@@ -3555,15 +3728,19 @@ async function buildPlan(specs, lock, opts = {}) {
     items.push({ spec, key, state, reason, ...quality ? { quality } : {} });
   }
   const isActionable = (i) => i.state === "missing" || i.state === "stale" || i.state === "failed";
-  const actionableKeys = new Set(items.filter(isActionable).map((i) => i.key));
+  const stateOf = new Map(items.map((i) => [i.key, i.state]));
   for (const item of items) {
     if (!isActionable(item)) continue;
-    const parent = item.spec.revision?.sourceSpec ?? item.spec.character?.parentSpec;
+    const parent = item.spec.mirror?.sourceSpec ?? item.spec.revision?.sourceSpec ?? item.spec.character?.parentSpec;
     if (!parent) continue;
     const parentKey = lockKey(parent.styleId, parent.assetId);
-    if (actionableKeys.has(parentKey)) {
+    const parentState = stateOf.get(parentKey);
+    if (parentState && isActionable({ state: parentState })) {
       item.state = "blocked";
       item.reason = `parent ${parentKey} is being generated in this run; this follows in the next wave`;
+    } else if (item.spec.mirror && (parentState === "recoverable" || parentState === "in-flight")) {
+      item.state = "blocked";
+      item.reason = `mirror source ${parentKey} is ${parentState}; this follows in the next wave`;
     }
   }
   const actionable = items.filter(isActionable);
@@ -3718,12 +3895,12 @@ async function confirm(question, auto) {
 }
 
 // src/cli/commands/account.ts
-import path21 from "path";
+import path22 from "path";
 import { existsSync as existsSync16 } from "fs";
 
 // src/env.ts
 import { readFileSync, existsSync as existsSync6 } from "fs";
-import path9 from "path";
+import path10 from "path";
 function loadEnvFiles(dir) {
   const loaded = [];
   for (const [file, vars] of envFiles(dir)) {
@@ -3746,7 +3923,7 @@ function readEnvFiles(dir) {
 function envFiles(dir) {
   const out = [];
   for (const name of [".env.local", ".env"]) {
-    const file = path9.join(dir, name);
+    const file = path10.join(dir, name);
     if (!existsSync6(file)) continue;
     try {
       out.push([file, parseEnv(readFileSync(file, "utf8"))]);
@@ -3776,8 +3953,8 @@ function parseEnv(contents) {
 
 // src/providers/comfyui.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile4 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile5 } from "fs/promises";
+import path11 from "path";
 
 // src/http.ts
 var MAX_RETRIES = 4;
@@ -3964,10 +4141,10 @@ var ComfyUIProvider = class _ComfyUIProvider {
   }
   async resolveOptions(value, context) {
     const options = parseOptions(value);
-    const workflowPath = path10.resolve(context.root, options.workflowFile);
+    const workflowPath = path11.resolve(context.root, options.workflowFile);
     let raw;
     try {
-      raw = await readFile4(workflowPath, "utf8");
+      raw = await readFile5(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)}`
@@ -4019,10 +4196,10 @@ var ComfyUIProvider = class _ComfyUIProvider {
           if (typeof item !== "string") {
             throw new Error(`ComfyUI ${label} must be a manifest-relative PNG or JPEG path`);
           }
-          const file = path10.resolve(context.root, item);
+          const file = path11.resolve(context.root, item);
           let bytes;
           try {
-            bytes = await readFile4(file);
+            bytes = await readFile5(file);
           } catch (error) {
             throw new Error(
               `ComfyUI ${label} could not be read at ${file}: ${error instanceof Error ? error.message : String(error)}`
@@ -4154,7 +4331,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
         setBinding(workflow2, binding, input);
         return;
       }
-      const bytes = await readFile4(input.path);
+      const bytes = await readFile5(input.path);
       if (sha256(bytes) !== input.sha256) {
         throw new Error(`ComfyUI provider input "${name}" changed before upload`);
       }
@@ -4221,7 +4398,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
       if (!spec.revision.sourceSha256 || !spec.revision.sourceFormat) {
         throw new Error("ComfyUI revision source is not ready");
       }
-      const sourceBytes = await readFile4(spec.revision.sourceFile);
+      const sourceBytes = await readFile5(spec.revision.sourceFile);
       if (sha256(sourceBytes) !== spec.revision.sourceSha256) {
         throw new Error("ComfyUI revision source changed before upload");
       }
@@ -4235,7 +4412,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
         if (!spec.revision.maskSha256 || !spec.revision.maskFormat) {
           throw new Error("ComfyUI revision mask is not ready");
         }
-        const maskBytes = await readFile4(spec.revision.maskFile);
+        const maskBytes = await readFile5(spec.revision.maskFile);
         if (sha256(maskBytes) !== spec.revision.maskSha256) {
           throw new Error("ComfyUI revision mask changed before upload");
         }
@@ -4709,7 +4886,7 @@ function canonical2(value) {
 import { mkdirSync, existsSync as existsSync7, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 import os from "os";
-import path11 from "path";
+import path12 from "path";
 
 // src/client.ts
 import { z as z2 } from "zod";
@@ -4848,9 +5025,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path44, init) {
+  async request(path45, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path44}`, {
+    const res = await this.http(`${BASE}${path45}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -4860,13 +5037,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path44} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path45} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path44} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path45} returned invalid JSON`);
     }
   }
   async balance() {
@@ -5051,10 +5228,10 @@ var PixelLabClient = class {
   async createCharacter(args) {
     const imageSize = { width: args.size, height: args.size };
     const palette = args.paletteSwatchBase64 ? { color_image: { type: "base64", base64: args.paletteSwatchBase64, format: "png" }, force_colors: true } : {};
-    let path44;
+    let path45;
     let body;
     if (args.mode === "v3") {
-      path44 = "/create-character-v3";
+      path45 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -5066,7 +5243,7 @@ var PixelLabClient = class {
         ...args.seed != null ? { seed: args.seed } : {}
       };
     } else if (args.mode === "pro") {
-      path44 = "/create-character-pro";
+      path45 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -5076,7 +5253,7 @@ var PixelLabClient = class {
         ...args.seed != null ? { seed: args.seed } : {}
       };
     } else {
-      path44 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path45 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -5089,8 +5266,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path44, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path44.slice(1));
+    const raw = await this.request(path45, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path45.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -5278,7 +5455,7 @@ var PixelLabProvider = class _PixelLabProvider {
    * filename, polling is an existence check, and downloading is a file read.
    */
   static cacheDir() {
-    const dir = path11.join(os.tmpdir(), "pixelkiln-pixflux");
+    const dir = path12.join(os.tmpdir(), "pixelkiln-pixflux");
     mkdirSync(dir, { recursive: true });
     return dir;
   }
@@ -5536,7 +5713,7 @@ var PixelLabProvider = class _PixelLabProvider {
         seed: spec.seed
       });
       const jobId = randomUUID3();
-      writeFileSync(path11.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), png);
+      writeFileSync(path12.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), png);
       return { jobId };
     }
     if (spec.generator === "tiles") {
@@ -5577,7 +5754,7 @@ var PixelLabProvider = class _PixelLabProvider {
   }
   async poll(jobId, generator, context) {
     if (generator === "pixflux") {
-      const file = path11.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+      const file = path12.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
       if (existsSync7(file)) {
         const sourceUrl = `file://${file}`;
         return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }] };
@@ -5861,9 +6038,9 @@ var RetroDiffusionClient = class {
     if (!response.ok) throw new ProviderError("retrodiffusion", `Retro Diffusion download failed (${response.status})`, { status: response.status });
     return Buffer.from(await response.arrayBuffer());
   }
-  async call(path44, init = {}) {
+  async call(path45, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path44}`, {
+    const response = await this.request(`${this.baseUrl}${path45}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -6720,13 +6897,13 @@ registerProvider({
 });
 
 // src/manifest.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import path12 from "path";
+import path13 from "path";
 async function loadManifest(manifestPath) {
-  const abs = path12.resolve(manifestPath);
+  const abs = path13.resolve(manifestPath);
   if (!existsSync8(abs)) throw new ProjectError(`No manifest at ${abs}`);
-  const input = ManifestInputSchema.safeParse(JSON.parse(await readFile5(abs, "utf8")));
+  const input = ManifestInputSchema.safeParse(JSON.parse(await readFile6(abs, "utf8")));
   if (!input.success) {
     const issues = formatManifestIssues(input.error.issues);
     throw new ProjectError(`Manifest at ${abs} is invalid:
@@ -6811,7 +6988,7 @@ ${issues}`);
     throw new ProjectError(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
-  return { manifest: parsed.data, root: path12.dirname(abs), path: abs };
+  return { manifest: parsed.data, root: path13.dirname(abs), path: abs };
 }
 function parentAssetId(asset) {
   return asset?.revision?.from ?? asset?.state?.of ?? asset?.animation?.of;
@@ -6911,11 +7088,11 @@ async function resolveSpecs(loaded, filter) {
   }
   const styleImageCache = /* @__PURE__ */ new Map();
   async function loadStyleImage(rel) {
-    const abs = path12.resolve(root, rel);
+    const abs = path13.resolve(root, rel);
     let hit = styleImageCache.get(abs);
     if (!hit) {
       if (!existsSync8(abs)) throw new Error(`Style image not found: ${abs}`);
-      const buf = await readFile5(abs);
+      const buf = await readFile6(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) {
@@ -6941,7 +7118,7 @@ async function resolveSpecs(loaded, filter) {
       styleImageDimensions.push(loadedImage);
     }
     const resolvedImages = style.styleImages.map((image) => {
-      const hit = styleImageCache.get(path12.resolve(root, image.path));
+      const hit = styleImageCache.get(path13.resolve(root, image.path));
       return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
     });
     const styleSpecs = /* @__PURE__ */ new Map();
@@ -6994,11 +7171,11 @@ async function resolveSpecs(loaded, filter) {
         );
       }
       const characterKind = asset.animation ? "animation" : asset.state ? "state" : "base";
-      const subject = asset.promptByStyle[styleId] ?? asset.prompt;
+      const subject = asset.promptByStyle[styleId] ?? asset.prompt ?? "";
       const prompt = generator === "character" && characterKind !== "base" ? subject.trim() : [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
-      const relFile = asset.file ?? path12.join(asset.category ?? "", `${assetId}.png`);
-      const outFile = path12.resolve(root, style.outDir, relFile);
-      const qualityOutFile = style.quality ? path12.resolve(root, style.quality.outDir, pngPath(relFile)) : void 0;
+      const relFile = asset.file ?? path13.join(asset.category ?? "", `${assetId}.png`);
+      const outFile = path13.resolve(root, style.outDir, relFile);
+      const qualityOutFile = style.quality ? path13.resolve(root, style.quality.outDir, pngPath(relFile)) : void 0;
       const tileSize = generator === "tiles" ? size : style.tileSize ?? 32;
       const tileVariations = tileFeatureOutputCount(generator === "tiles" ? style.tileFeature : void 0) ?? tileVariationCount(countNumberedDescriptions(prompt));
       const base = {
@@ -7051,7 +7228,7 @@ async function resolveSpecs(loaded, filter) {
             minGridConfidence: style.quality.minGridConfidence,
             ...style.quality.minTransparency == null ? {} : { minTransparency: style.quality.minTransparency },
             ...style.quality.fixerRevision ? { fixerRevision: style.quality.fixerRevision } : {},
-            ...style.quality.fixerPython ? { fixerPython: path12.resolve(root, style.quality.fixerPython) } : {},
+            ...style.quality.fixerPython ? { fixerPython: path13.resolve(root, style.quality.fixerPython) } : {},
             ...style.quality.fps == null ? {} : { fps: style.quality.fps }
           }
         } : {},
@@ -7069,11 +7246,42 @@ async function resolveSpecs(loaded, filter) {
       const resolved = styleSpecs.get(assetId);
       if (!resolved) {
         throw new Error(
-          `Asset "${assetId}" is not available in style "${styleId}"; revision parents must participate in the same style.`
+          `Asset "${assetId}" is not available in style "${styleId}"; revision parents, character parents, and mirror sources must be in the same style.`
         );
       }
       if (finalized.has(assetId)) return resolved;
       const asset = manifest.assets[assetId];
+      if (asset.mirror) {
+        if (asset.mirror === assetId) throw new Error(`assets.${assetId}: an asset cannot mirror itself`);
+        const sourceSpec = await finalize(asset.mirror);
+        if (sourceSpec.generator === "tiles") {
+          throw new Error(`assets.${assetId}: a tile set cannot be mirrored; its edges carry meaning`);
+        }
+        if (sourceSpec.character?.kind === "animation") {
+          const facing = sourceSpec.character.animation.direction;
+          const mirrored = MIRRORED_DIRECTION[facing];
+          if (mirrored === facing) {
+            throw new Error(
+              `assets.${assetId}: mirroring ${asset.mirror} gives another ${facing}-facing loop; mirror a loop facing east, west, or a diagonal`
+            );
+          }
+          resolved.character = { ...sourceSpec.character, animation: { ...sourceSpec.character.animation, direction: mirrored } };
+        } else if (sourceSpec.character) {
+          resolved.character = { ...sourceSpec.character };
+        }
+        resolved.mirror = { sourceAssetId: asset.mirror, sourceSpec };
+        resolved.generator = sourceSpec.generator;
+        resolved.width = sourceSpec.width;
+        resolved.height = sourceSpec.height;
+        resolved.size = sourceSpec.size;
+        resolved.prompt = "";
+        resolved.specHash = specHash(resolved, styleImageHashes, providerOptionIdentity, providerInputIdentities.get(assetId));
+        resolved.cost = 0;
+        resolved.costUnit = sourceSpec.costUnit;
+        resolved.candidates = 1;
+        finalized.add(assetId);
+        return resolved;
+      }
       const characterParent = asset.state?.of ?? asset.animation?.of;
       if (resolved.character && characterParent) {
         const parentSpec = await finalize(characterParent);
@@ -7097,9 +7305,9 @@ async function resolveSpecs(loaded, filter) {
           );
         }
         const sourceSpec = await finalize(asset.revision.from);
-        const sourceFile = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path12.resolve(root, sourceSpec.source) : sourceSpec.outFile);
+        const sourceFile = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path13.resolve(root, sourceSpec.source) : sourceSpec.outFile);
         const sourceImage = await optionalRevisionImage(sourceFile, "revision source");
-        const maskFile = asset.revision.mask ? path12.resolve(root, asset.revision.mask) : void 0;
+        const maskFile = asset.revision.mask ? path13.resolve(root, asset.revision.mask) : void 0;
         const maskImage = maskFile ? await optionalRevisionImage(maskFile, "revision mask", "png") : null;
         if (sourceImage && maskImage && (sourceImage.width !== maskImage.width || sourceImage.height !== maskImage.height)) {
           throw new Error(
@@ -7180,12 +7388,12 @@ async function resolveSpecs(loaded, filter) {
   return specs;
 }
 function pngPath(file) {
-  const extension = path12.extname(file);
+  const extension = path13.extname(file);
   return extension ? `${file.slice(0, -extension.length)}.png` : `${file}.png`;
 }
 async function optionalRevisionImage(file, label, requiredFormat) {
   if (!existsSync8(file)) return null;
-  const bytes = await readFile5(file);
+  const bytes = await readFile6(file);
   const metadata = imageMetadata(bytes);
   if (!metadata) throw new Error(`${label} is not a readable PNG or JPEG: ${file}`);
   if (requiredFormat && metadata.format !== requiredFormat) {
@@ -7198,8 +7406,8 @@ async function resolveStyleImages(loaded, styleId) {
   if (!style) throw new Error(`Unknown style "${styleId}"`);
   const out = [];
   for (const img of style.styleImages) {
-    const file = path12.resolve(loaded.root, img.path);
-    const buf = await readFile5(file);
+    const file = path13.resolve(loaded.root, img.path);
+    const buf = await readFile6(file);
     const metadata = imageMetadata(buf);
     if (!metadata) throw new Error(`Style image is not a readable PNG or JPEG: ${file}`);
     if (metadata.width < 1 || metadata.height < 1) {
@@ -7268,8 +7476,8 @@ function resolveCharacterShape(asset, style, kind) {
 
 // src/pipeline/fetch.ts
 import { existsSync as existsSync9, readFileSync as readFileSync3 } from "fs";
-import { mkdir as mkdir3, readFile as readFile6, rename as rename3, rm as rm4, writeFile as writeFile3 } from "fs/promises";
-import path13 from "path";
+import { mkdir as mkdir4, readFile as readFile7, rename as rename4, rm as rm4, writeFile as writeFile4 } from "fs/promises";
+import path14 from "path";
 
 // src/source-url.ts
 var SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
@@ -7315,9 +7523,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   const result = { downloaded: 0, skipped: 0, failed: 0, ...opts.refresh ? { unchanged: 0 } : {} };
   const specByKey = new Map(specs.map((s) => [lockKey(s.styleId, s.assetId), s]));
   normalizeLockOutputPaths(lock, specs);
-  const cacheDir = opts.cacheDir === false ? null : path13.resolve(opts.cacheDir ?? path13.join(path13.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : path14.resolve(opts.cacheDir ?? path14.join(path14.dirname(lockPath), ".pixelkiln", "cache"));
   const pending = Object.entries(lock.entries).filter(([key, e]) => {
     if (e.provider !== provider.id || !specByKey.has(key)) return false;
+    if (specByKey.get(key)?.mirror) return false;
     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);
@@ -7416,7 +7625,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             if (!source.url) throw new Error(`no durable source URL to refresh ${source.role ?? "asset"} from`);
             fresh = await provider.download(source.url);
             if (recorded && sha256(fresh) === recordedRaw && !reapply) {
-              log2(`  current ${path13.relative(process.cwd(), target)}`);
+              log2(`  current ${path14.relative(process.cwd(), target)}`);
               outputs.push({ ...recorded, path: portableOutputPath(target, spec.root) });
               continue;
             }
@@ -7430,7 +7639,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
                 if (cacheDir) {
                   await cacheMedia(
                     cacheDir,
-                    await readFile6(target),
+                    await readFile7(target),
                     recorded.mediaType ?? MediaType.PNG,
                     recorded.sha256
                   );
@@ -7439,10 +7648,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
                 continue;
               }
               if (reapply && !fresh) {
-                if (!recorded.raw) raw = await readFile6(target);
-                log2(`  reapply ${path13.relative(process.cwd(), target)}`);
+                if (!recorded.raw) raw = await readFile7(target);
+                log2(`  reapply ${path14.relative(process.cwd(), target)}`);
               } else {
-                log2(`  changed ${path13.relative(process.cwd(), target)} (upstream)`);
+                log2(`  changed ${path14.relative(process.cwd(), target)} (upstream)`);
               }
             } else {
               const superseded = (entry.supersededOutputs ?? []).find(
@@ -7461,7 +7670,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
                 }
               }
               log2(
-                `  replace ${path13.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
+                `  replace ${path14.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
               );
             }
           }
@@ -7470,7 +7679,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           } else if (!raw && recorded && cacheDir) {
             if (!reapply) final = await readCachedMedia(cacheDir, recorded.sha256, expectedMediaType);
             if (!final && recordedRaw) raw = await readCachedMedia(cacheDir, recordedRaw, expectedMediaType);
-            if (final || raw) log2(`  cached  ${path13.relative(process.cwd(), target)}`);
+            if (final || raw) log2(`  cached  ${path14.relative(process.cwd(), target)}`);
           }
           if (!final && !raw) {
             if (!source.url) {
@@ -7497,13 +7706,13 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             buf = processed.bytes;
             if (processed.changed) {
               rawHash = sha256(raw);
-              log2(`  snapped ${path13.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
+              log2(`  snapped ${path14.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
             }
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await mkdir3(path13.dirname(target), { recursive: true });
+          await mkdir4(path14.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
-          await writeFile3(tmp, buf);
+          await writeFile4(tmp, buf);
           outputs.push({
             path: portableOutputPath(target, spec.root),
             sha256: sha256(buf),
@@ -7513,9 +7722,9 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           });
           upsert(lock, key, { outputs: mergeOutputs(entry.outputs, outputs) });
           await saveLock(lockPath, lock);
-          await rename3(tmp, target);
+          await rename4(tmp, target);
           wrote = true;
-          log2(`  wrote   ${path13.relative(process.cwd(), target)}`);
+          log2(`  wrote   ${path14.relative(process.cwd(), target)}`);
         }
         if (opts.refresh && !wrote) {
           if (rotated) {
@@ -7559,10 +7768,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = path13.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path14.join(cacheDir, cacheFileName(hash, mediaType));
   if (!existsSync9(file)) return null;
   try {
-    const buf = await readFile6(file);
+    const buf = await readFile7(file);
     if (sha256(buf) !== hash) return null;
     validateMedia(buf, mediaType);
     return buf;
@@ -7573,13 +7782,13 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = path13.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path14.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
-  await mkdir3(cacheDir, { recursive: true });
+  await mkdir4(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  await writeFile3(tmp, buf);
+  await writeFile4(tmp, buf);
   try {
-    await rename3(tmp, file);
+    await rename4(tmp, file);
   } catch (err) {
     if (!existsSync9(file)) throw err;
   } finally {
@@ -7615,11 +7824,11 @@ async function pushTags(provider, specs, lock, opts = {}) {
 
 // src/pipeline/adopt.ts
 import { existsSync as existsSync11 } from "fs";
-import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
-import path14 from "path";
+import { readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
+import path15 from "path";
 
 // src/cache.ts
-import { mkdir as mkdir4, readFile as readFile7, rename as rename4, rm as rm5, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile8, rename as rename5, rm as rm5, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
 import pathModule from "path";
 import { z as z3 } from "zod";
@@ -7635,10 +7844,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path44) {
-  if (!existsSync10(path44)) return { version: 1, hashes: {} };
+async function loadCache(path45) {
+  if (!existsSync10(path45)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile7(path44, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path45, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -7650,18 +7859,18 @@ async function loadCache(path44) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path44, cache) {
+async function saveCache(path45, 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 mkdir4(pathModule.dirname(pathModule.resolve(path44)), { recursive: true });
-  const tmp = `${path44}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir5(pathModule.dirname(pathModule.resolve(path45)), { recursive: true });
+  const tmp = `${path45}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile4(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename4(tmp, path44);
+    await writeFile5(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
+    await rename5(tmp, path45);
   } finally {
     await rm5(tmp, { force: true });
   }
@@ -7699,7 +7908,7 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
-    const bytes = await readFile8(spec.outFile);
+    const bytes = await readFile9(spec.outFile);
     try {
       decodePng(bytes);
     } catch (err) {
@@ -7819,7 +8028,7 @@ async function writePromptsBack(manifestPath, lock, opts = {}) {
   const log2 = opts.onProgress ?? (() => {
   });
   const selectedAssets = opts.assetIds ? new Set(opts.assetIds) : null;
-  const raw = JSON.parse(await readFile8(manifestPath, "utf8"));
+  const raw = JSON.parse(await readFile9(manifestPath, "utf8"));
   const best = /* @__PURE__ */ new Map();
   for (const entry of Object.values(lock.entries)) {
     if (opts.provider && entry.provider !== opts.provider) continue;
@@ -7841,7 +8050,7 @@ async function writePromptsBack(manifestPath, lock, opts = {}) {
       stillEmpty.push(id);
     }
   }
-  await writeFile5(manifestPath, JSON.stringify(raw, null, 2) + "\n");
+  await writeFile6(manifestPath, JSON.stringify(raw, null, 2) + "\n");
   log2(`  filled ${filled} prompt(s) from adopted objects`);
   return { filled, stillEmpty };
 }
@@ -7853,14 +8062,14 @@ function formatUnmatchedRemote(objects, limit = 15) {
 
 // src/pipeline/adopt-characters.ts
 import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir5, readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
-import path15 from "path";
+import { mkdir as mkdir6, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
+import path16 from "path";
 async function adoptCharacters(provider, specs, lock, lockPath, opts) {
   const log2 = opts.onProgress ?? (() => {
   });
   const result = { scanned: 0, matched: 0, unmatched: [], remaining: [], written: [], differing: [] };
   if (!provider.listCharacters || !provider.getCharacter) return result;
-  const wanted = specs.filter((spec) => spec.character);
+  const wanted = specs.filter((spec) => spec.character && !spec.mirror);
   if (!wanted.length) return result;
   const remote = [];
   for await (const character of provider.listCharacters()) remote.push(character);
@@ -7906,11 +8115,11 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
       const hash = sha256(bytes);
       const file = expectedOutputPath(spec, source.role, index, sources.length);
       if (existsSync12(file)) {
-        if (sha256(await readFile9(file)) !== hash) result.differing.push(path15.relative(process.cwd(), file));
+        if (sha256(await readFile10(file)) !== hash) result.differing.push(path16.relative(process.cwd(), file));
       } else {
-        await mkdir5(path15.dirname(file), { recursive: true });
-        await writeFile6(file, bytes);
-        result.written.push(path15.relative(process.cwd(), file));
+        await mkdir6(path16.dirname(file), { recursive: true });
+        await writeFile7(file, bytes);
+        result.written.push(path16.relative(process.cwd(), file));
       }
       outputs.push({ path: portableOutputPath(file, spec.root), sha256: hash, ...source.role ? { role: source.role } : {} });
     }
@@ -7949,10 +8158,10 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
     } else {
       const south = expectedOutputPath(spec, "south", 0, spec.character.directions);
       if (!existsSync12(south)) {
-        result.unmatched.push(`${key}: no remoteId and no ${path15.relative(process.cwd(), south)} to match by`);
+        result.unmatched.push(`${key}: no remoteId and no ${path16.relative(process.cwd(), south)} to match by`);
         return false;
       }
-      const localHash = sha256(await readFile9(south));
+      const localHash = sha256(await readFile10(south));
       for (const candidate of remote) {
         if (claimed.has(candidate.id)) continue;
         if (await southHash(candidate) === localHash) {
@@ -7961,7 +8170,7 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
         }
       }
       if (!match) {
-        result.unmatched.push(`${key}: no character's south rotation has the bytes of ${path15.relative(process.cwd(), south)}`);
+        result.unmatched.push(`${key}: no character's south rotation has the bytes of ${path16.relative(process.cwd(), south)}`);
         return false;
       }
     }
@@ -8031,12 +8240,12 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
       if (!existsSync12(first)) {
         const byName = candidates.find((a) => a.name === characterAnimationName(spec));
         if (!byName) {
-          result.unmatched.push(`${key}: no remoteId and no ${path15.relative(process.cwd(), first)} to match by`);
+          result.unmatched.push(`${key}: no remoteId and no ${path16.relative(process.cwd(), first)} to match by`);
           return false;
         }
         match = byName;
       } else {
-        const localHash = sha256(await readFile9(first));
+        const localHash = sha256(await readFile10(first));
         for (const candidate of candidates) {
           if (sha256(await download(candidate.frames[0])) === localHash) {
             match = candidate;
@@ -8044,7 +8253,7 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
           }
         }
         if (!match) {
-          result.unmatched.push(`${key}: no ${animation.direction} animation of character ${parentId} starts with the bytes of ${path15.relative(process.cwd(), first)}`);
+          result.unmatched.push(`${key}: no ${animation.direction} animation of character ${parentId} starts with the bytes of ${path16.relative(process.cwd(), first)}`);
           return false;
         }
       }
@@ -8104,9 +8313,9 @@ async function adoptCharacters(provider, specs, lock, lockPath, opts) {
 }
 
 // src/pipeline/salvage.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
-import path16 from "path";
+import path17 from "path";
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
@@ -8116,7 +8325,7 @@ async function loadClaims(lockPaths, opts = {}) {
     if (!existsSync13(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile10(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile11(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -8164,20 +8373,20 @@ function matchStyleByPattern(prompt, manifest) {
   return null;
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path16.resolve(ownManifestPath);
+  const own = path17.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path16.join(path16.dirname(path16.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path17.join(path17.dirname(path17.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path16.resolve(siblingManifestPath) === own) continue;
+    if (path17.resolve(siblingManifestPath) === own) continue;
     if (!existsSync13(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path16.basename(path16.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path17.basename(path17.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -8293,9 +8502,9 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/workspace.ts
-import { mkdir as mkdir6, readFile as readFile11, rename as rename5, rm as rm6, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile12, rename as rename6, rm as rm6, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
-import path17 from "path";
+import path18 from "path";
 import { z as z4 } from "zod";
 var WorkspaceProjectSchema = z4.object({
   id: z4.string().min(1),
@@ -8323,7 +8532,7 @@ async function loadWorkspace(workspacePath) {
   if (!existsSync14(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await readFile11(workspacePath, "utf8"));
+    raw = JSON.parse(await readFile12(workspacePath, "utf8"));
   } catch (err) {
     throw new ProjectError(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -8337,22 +8546,22 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await mkdir6(path17.dirname(path17.resolve(workspacePath)), { recursive: true });
+  await mkdir7(path18.dirname(path18.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile7(tmp, JSON.stringify(sorted, null, 2) + "\n");
-    await rename5(tmp, workspacePath);
+    await writeFile8(tmp, JSON.stringify(sorted, null, 2) + "\n");
+    await rename6(tmp, workspacePath);
   } finally {
     await rm6(tmp, { force: true });
   }
 }
 function toPortablePath(dir, absolute) {
-  return path17.relative(dir, absolute).split(path17.sep).join("/");
+  return path18.relative(dir, absolute).split(path18.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: path17.resolve(dir, project.manifest.split("/").join(path17.sep)),
-    lockPath: path17.resolve(dir, project.lock.split("/").join(path17.sep))
+    manifestPath: path18.resolve(dir, project.manifest.split("/").join(path18.sep)),
+    lockPath: path18.resolve(dir, project.lock.split("/").join(path18.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -8365,7 +8574,7 @@ function validateWorkspace(ws, dir) {
     const { manifestPath, lockPath } = resolveProject(dir, project);
     lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
     manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
-    if (path17.isAbsolute(project.manifest) || path17.isAbsolute(project.lock)) {
+    if (path18.isAbsolute(project.manifest) || path18.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
@@ -8426,8 +8635,8 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir7, writeFile as writeFile8, readFile as readFile13 } from "fs/promises";
-import path18 from "path";
+import { mkdir as mkdir8, writeFile as writeFile9, readFile as readFile14 } from "fs/promises";
+import path19 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -8587,7 +8796,7 @@ refresh();
 
 // src/pick/review-server.ts
 import { createServer } from "http";
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 
 // src/open.ts
 import { spawn } from "child_process";
@@ -8614,7 +8823,7 @@ function serveReviewPage(opts) {
       if (req.method === "GET" && req.url && opts.assets?.has(req.url)) {
         try {
           const asset = opts.assets.get(req.url);
-          const bytes = await readFile12(asset.path);
+          const bytes = await readFile13(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -8691,7 +8900,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path18.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]));
@@ -8720,10 +8929,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 = path18.join("_salvaged", `${assetId}.png`);
-            const outFile = path18.resolve(ctx.importDir, rel);
-            await mkdir7(path18.dirname(outFile), { recursive: true });
-            await writeFile8(outFile, buf);
+            const rel = path19.join("_salvaged", `${assetId}.png`);
+            const outFile = path19.resolve(ctx.importDir, rel);
+            await mkdir8(path19.dirname(outFile), { recursive: true });
+            await writeFile9(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -8755,7 +8964,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path18.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path19.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -8779,9 +8988,9 @@ 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 writeFile8(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile9(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       return result;
     }
@@ -8789,19 +8998,19 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 }
 
 // src/cli/project.ts
-import path20 from "path";
+import path21 from "path";
 import { existsSync as existsSync15 } from "fs";
 
 // src/project.ts
-import path19 from "path";
+import path20 from "path";
 async function openProject(manifestPath = "pixelkiln.manifest.json", opts = {}) {
-  const absolute = path19.resolve(manifestPath);
-  const root = path19.dirname(absolute);
+  const absolute = path20.resolve(manifestPath);
+  const root = path20.dirname(absolute);
   if (opts.env !== false) {
     loadEnvFiles(root);
-    if (path19.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
+    if (path20.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
   }
-  const lockPath = path19.resolve(opts.lockPath ?? path19.join(root, "pixelkiln.lock.json"));
+  const lockPath = path20.resolve(opts.lockPath ?? path20.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);
@@ -8932,7 +9141,7 @@ async function workspaceStatus(ws, dir) {
 
 // src/cli/project.ts
 async function provenanceFile(id, file) {
-  const absolute = path20.resolve(file);
+  const absolute = path21.resolve(file);
   return {
     id,
     path: absolute,
@@ -9011,7 +9220,7 @@ async function requireCompleteWorkspaceClaims(workspacePath) {
   if (!existsSync15(workspacePath)) {
     throw new ProjectError(`Workspace catalog not found: ${workspacePath}`);
   }
-  const dir = path20.dirname(path20.resolve(workspacePath));
+  const dir = path21.dirname(path21.resolve(workspacePath));
   const ws = await loadWorkspace(workspacePath);
   const diagnostics = validateWorkspace(ws, dir);
   const errors = diagnostics.filter((d) => d.level === "error");
@@ -9034,9 +9243,9 @@ async function openAccountProject(args) {
   return project;
 }
 async function open(args) {
-  if (!existsSync15(path20.resolve(args.manifest))) {
+  if (!existsSync15(path21.resolve(args.manifest))) {
     throw new ProjectError(
-      `No manifest at ${path20.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
+      `No manifest at ${path21.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
     );
   }
   const project = await openProject(args.manifest, { lockPath: args.lock, styles: args.styles, assets: args.assets });
@@ -9078,7 +9287,7 @@ function providerCache(mode2) {
 
 // src/cli/commands/account.ts
 async function runBalance(args) {
-  loadEnvFiles(path21.dirname(path21.resolve(args.manifest)));
+  loadEnvFiles(path22.dirname(path22.resolve(args.manifest)));
   loadEnvFiles(process.cwd());
   const loaded = await loadManifest(args.manifest);
   const selectedProvider = accountProviderId(loaded.manifest, args.provider, "balance");
@@ -9151,12 +9360,12 @@ async function runAdopt(args) {
   tagged ${n} object(s) upstream`);
   }
   if (args.writePrompts) {
-    const { filled, stillEmpty } = await writePromptsBack(path21.resolve(args.manifest), lock, {
+    const { filled, stillEmpty } = await writePromptsBack(path22.resolve(args.manifest), lock, {
       onProgress: log,
       provider: provider.id,
       assetIds: specs.map((spec) => spec.assetId)
     });
-    log(`  recovered ${filled} prompt(s) into ${path21.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,
@@ -9186,12 +9395,12 @@ async function runSalvage2(args) {
   const provider = providerFor(accountProvider);
   const jsonMode = args.dryRun && args.json;
   const diag = jsonMode ? (msg = "") => console.error(msg) : log;
-  const ownLock = path21.resolve(args.lock);
+  const ownLock = path22.resolve(args.lock);
   let workspaceProjects = [];
   let workspaceDir = "";
   if (args.workspace) {
-    const workspacePath = path21.resolve(args.workspace);
-    workspaceDir = path21.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}`);
@@ -9201,11 +9410,11 @@ async function runSalvage2(args) {
     .../* @__PURE__ */ new Set([
       ...workspaceLockPaths,
       ...existsSync16(ownLock) ? [ownLock] : [],
-      ...args.claims.map((c) => path21.resolve(c))
+      ...args.claims.map((c) => path22.resolve(c))
     ])
   ];
   diag(`  claim set (${lockPaths.length} lockfile(s)):`);
-  for (const p of lockPaths) diag(`    ${path21.relative(process.cwd(), p)}`);
+  for (const p of lockPaths) diag(`    ${path22.relative(process.cwd(), p)}`);
   if (!args.claims.length && !args.workspace) {
     diag(
       `
@@ -9213,7 +9422,7 @@ async function runSalvage2(args) {
   pass every other project's lockfile via --claims a.json,b.json, or
   register every project in a workspace catalog and pass --workspace.`
     );
-  } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path21.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
@@ -9297,7 +9506,7 @@ async function runSalvage2(args) {
         manifestPath: loaded.path,
         manifest: accountManifest,
         styleId,
-        importDir: path21.resolve(loaded.root, style.outDir),
+        importDir: path22.resolve(loaded.root, style.outDir),
         lock,
         lockPath: args.lock
       },
@@ -9398,17 +9607,17 @@ async function runTag(args) {
 }
 
 // src/cli/commands/edit.ts
-import path24 from "path";
+import path25 from "path";
 
 // src/pipeline/hand-edit.ts
 import { existsSync as existsSync17 } from "fs";
-import { copyFile, mkdir as mkdir8, readFile as readFile15, rename as rename7, rm as rm8, writeFile as writeFile10 } from "fs/promises";
-import path23 from "path";
+import { copyFile, mkdir as mkdir9, readFile as readFile16, rename as rename8, rm as rm8, writeFile as writeFile11 } from "fs/promises";
+import path24 from "path";
 import { z as z6 } from "zod";
 
 // src/manifest-edit.ts
-import { readFile as readFile14, rename as rename6, rm as rm7, writeFile as writeFile9 } from "fs/promises";
-import path22 from "path";
+import { readFile as readFile15, rename as rename7, rm as rm7, writeFile as writeFile10 } from "fs/promises";
+import path23 from "path";
 import { z as z5 } from "zod";
 var HexSha = z5.string().regex(/^[0-9a-f]{64}$/);
 var AssetPatchSchema = z5.object({
@@ -9623,8 +9832,8 @@ function applyEdit(raw, edit) {
   }
 }
 async function applyManifestEdit(manifestPath, edit) {
-  const absolute = path22.resolve(manifestPath);
-  const original = await readFile14(absolute, "utf8");
+  const absolute = path23.resolve(manifestPath);
+  const original = await readFile15(absolute, "utf8");
   const before = sha256(original);
   if (before !== edit.expectedSha256) throw new ManifestDriftError(absolute);
   let raw;
@@ -9638,12 +9847,12 @@ async function applyManifestEdit(manifestPath, edit) {
   applyEdit(raw, edit);
   const next = serializeLike(original, raw);
   if (next === original) return { manifestPath: absolute, sha256: before, changed: false };
-  const tmp = path22.join(
-    path22.dirname(absolute),
-    `.${path22.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
+  const tmp = path23.join(
+    path23.dirname(absolute),
+    `.${path23.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
   );
   try {
-    await writeFile9(tmp, next);
+    await writeFile10(tmp, next);
     try {
       const loaded = await loadManifest(tmp);
       await resolveSpecs(loaded);
@@ -9651,7 +9860,7 @@ async function applyManifestEdit(manifestPath, edit) {
       const message6 = error instanceof Error ? error.message : String(error);
       throw new ManifestEditError(message6.replace(tmp, absolute));
     }
-    await rename6(tmp, absolute);
+    await rename7(tmp, absolute);
   } finally {
     await rm7(tmp, { force: true });
   }
@@ -9662,11 +9871,11 @@ async function applyManifestEdit(manifestPath, edit) {
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
-  const outDir = path23.resolve(loaded.root, style?.outDir ?? ".");
-  const relative = path23.relative(outDir, spec.outFile);
-  const inside = relative && !relative.startsWith("..") && !path23.isAbsolute(relative);
-  const file = inside ? relative : path23.basename(spec.outFile);
-  return path23.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
+  const outDir = path24.resolve(loaded.root, style?.outDir ?? ".");
+  const relative = path24.relative(outDir, spec.outFile);
+  const inside = relative && !relative.startsWith("..") && !path24.isAbsolute(relative);
+  const file = inside ? relative : path24.basename(spec.outFile);
+  return path24.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
 }
 function handEditBases(spec, lock) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -9708,7 +9917,7 @@ async function startHandEdit(loaded, lock, spec, opts = {}) {
       `${spec.styleId}/${spec.assetId} declares ${spec.source}, one committed file placed for the whole set; clear that source (pixelkiln edit detach) to hand-edit the members one by one`
     );
   }
-  const existing = spec.source ? path23.resolve(loaded.root, spec.source) : null;
+  const existing = spec.source ? path24.resolve(loaded.root, spec.source) : null;
   const editPath = existing ?? handEditPath(loaded, spec);
   const members = handEditMembers(loaded, spec, lock, editPath);
   let created = false;
@@ -9719,7 +9928,7 @@ async function startHandEdit(loaded, lock, spec, opts = {}) {
         `${spec.styleId}/${spec.assetId} has no generated PNG on disk to start from; generate or restore it first`
       );
     }
-    await mkdir8(path23.dirname(member.path), { recursive: true });
+    await mkdir9(path24.dirname(member.path), { recursive: true });
     await copyFile(member.base, member.path);
     created = true;
   }
@@ -9798,7 +10007,7 @@ function handEditProjectPath(editPath) {
 async function readHandEditCompanion(editPath) {
   let text;
   try {
-    text = await readFile15(handEditCompanionPath(editPath), "utf8");
+    text = await readFile16(handEditCompanionPath(editPath), "utf8");
   } catch {
     return null;
   }
@@ -9841,7 +10050,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     }
   });
   const bases = handEditBases(spec, lock);
-  const expectedSize = bases?.[0] ? decodePng(await readFile15(bases[0].path)) : { width: spec.width, height: spec.height };
+  const expectedSize = bases?.[0] ? decodePng(await readFile16(bases[0].path)) : { width: spec.width, height: spec.height };
   for (const [index, image] of decoded.entries()) {
     if (image.width !== expectedSize.width || image.height !== expectedSize.height) {
       const which = memberSet ? `member ${incoming[index].role ?? index}` : "the edit";
@@ -9857,7 +10066,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     editor: input.editor,
     protocol: input.protocol,
     savedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
-    project: projectPath ? path23.basename(projectPath) : null,
+    project: projectPath ? path24.basename(projectPath) : null,
     outputs: incoming.map((frame, index) => ({
       role: frame.role,
       basedOn: basedOnHash(entry, index),
@@ -9887,8 +10096,8 @@ function basedOnHash(entry, index) {
 async function replaceFile(file, bytes) {
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile10(tmp, bytes);
-    await rename7(tmp, file);
+    await writeFile11(tmp, bytes);
+    await rename8(tmp, file);
   } finally {
     await rm8(tmp, { force: true });
   }
@@ -9917,7 +10126,7 @@ async function runEdit(args) {
   const set = started.members.length > 1;
   const kind = spec.generator === "frames" ? "frames" : "members";
   log(`  ${started.created ? "created" : "found"} ${started.source}${set ? ` (${started.members.length} ${kind})` : ""}${started.declared ? " and declared it as the asset's source" : ""}`);
-  if (set) for (const member of started.members) log(`    ${member.role ?? ""}  ${path24.relative(process.cwd(), member.path)}`);
+  if (set) for (const member of started.members) log(`    ${member.role ?? ""}  ${path25.relative(process.cwd(), member.path)}`);
   if (args.noOpen) {
     log(`  edit ${set ? "them" : "it"} with your own tool, then run pixelkiln plan; mount and pack place ${set ? "them" : "it"} in place of the generated art`);
   } else {
@@ -9927,17 +10136,17 @@ async function runEdit(args) {
 }
 
 // src/cli/commands/gallery.ts
-import path31 from "path";
+import path32 from "path";
 import { existsSync as existsSync23 } from "fs";
 
 // src/gallery/snapshot.ts
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync19 } from "fs";
-import { readFile as readFile16, stat as stat2 } from "fs/promises";
-import path27 from "path";
+import { readFile as readFile17, stat as stat2 } from "fs/promises";
+import path28 from "path";
 
 // src/gallery/edit.ts
-import path25 from "path";
+import path26 from "path";
 import { z as z7 } from "zod";
 var Base64 = z7.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
 var HandEditRequestSchema = z7.discriminatedUnion("action", [
@@ -10027,7 +10236,7 @@ function createGalleryEditHandler(opts) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = path25.relative(process.cwd(), result.manifestPath);
+      const relative = path26.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
       const subject = parsed.data.action === "patch-style" ? `style ${parsed.data.styleId}` : parsed.data.action === "set-source" || parsed.data.action === "clear-source" ? `${parsed.data.styleId}/${parsed.data.assetId} source` : parsed.data.assetId;
       log2(`  manifest edited: ${parsed.data.action === "add-asset" ? "added" : "changed"} ${subject} in ${shown}`);
@@ -10038,7 +10247,7 @@ function createGalleryEditHandler(opts) {
 
 // src/pipeline/history.ts
 import { existsSync as existsSync18 } from "fs";
-import path26 from "path";
+import path27 from "path";
 var HISTORY_ENV = "PIXELKILN_HISTORY";
 function historyLimit(manifest, env = process.env) {
   if (manifest?.history !== void 0) return manifest.history;
@@ -10127,7 +10336,7 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
     if (!existsSync18(file)) continue;
     if (await sha256File(file) !== entry.outputs[i].sha256 && !opts.force) {
       throw new OverwriteRefusedError(
-        `${path26.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
+        `${path27.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
         [file]
       );
     }
@@ -10179,7 +10388,7 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return createHash3("sha256").update(path27.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return createHash3("sha256").update(path28.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -10198,7 +10407,7 @@ function describeHistory(media, entry, cacheDir) {
   return (entry.history ?? []).map((generation, i) => {
     const outputs = generation.outputs.map((output) => {
       const mediaType = output.mediaType ?? MediaType.PNG;
-      const file = path27.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = path28.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
       if (existsSync19(file)) {
         const id = galleryMediaId(file);
@@ -10229,7 +10438,7 @@ function describeHistory(media, entry, cacheDir) {
 var MAX_COMPARED_BYTES = 8 * 1024 * 1024;
 async function samePixels(a, b) {
   try {
-    const [left, right] = await Promise.all([readFile16(a), readFile16(b)]);
+    const [left, right] = await Promise.all([readFile17(a), readFile17(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -10299,9 +10508,9 @@ async function describeOutput(media, root, absolutePath, recorded = {}) {
 async function describeQuality(media, root, inspection) {
   const outputPaths = inspection.outputs ?? [inspection.output];
   const outputs = await Promise.all(
-    outputPaths.map((file) => describeOutput(media, root, path27.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, path28.resolve(root, file)))
   );
-  const recordPath = path27.resolve(root, inspection.record);
+  const recordPath = path28.resolve(root, inspection.record);
   const recordExists = existsSync19(recordPath);
   let options = null;
   let check = null;
@@ -10321,7 +10530,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path27.resolve(root, inspection.output), root),
+    output: portableOutputPath(path28.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -10358,9 +10567,9 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await readFile16(loaded.path, "utf8");
+  const manifestText = await readFile17(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = path27.resolve(path27.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = path28.resolve(path28.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -10384,7 +10593,7 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path27.resolve(root, spec.source);
+        const editPath = path28.resolve(root, spec.source);
         const memberCount = sourceIsStem(spec.source, entry, root) ? entry.outputs.length : 1;
         const editShas = await Promise.all(
           Array.from({ length: memberCount }, async (_, index) => {
@@ -10433,7 +10642,7 @@ async function buildGallerySnapshot(opts) {
         editStatus = edits.some((member) => !member.exists) ? "missing" : editChanged.every((changed) => !changed) ? "same" : regenerated ? "regenerated-since" : "edited";
       }
     } else if (spec.source) {
-      outputs = [await describeOutput(media, root, path27.resolve(root, spec.source))];
+      outputs = [await describeOutput(media, root, path28.resolve(root, spec.source))];
     } else if (!entry && existsSync19(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
@@ -10473,6 +10682,7 @@ async function buildGallerySnapshot(opts) {
       currentSpecHash: spec.specHash,
       revision: entry?.revision ?? null,
       revisionParentKey: spec.revision ? lockKey(spec.styleId, spec.revision.sourceAssetId) : entry?.revision ? lockKey(spec.styleId, entry.revision.sourceAssetId) : null,
+      mirrorOfKey: spec.mirror ? lockKey(spec.styleId, spec.mirror.sourceAssetId) : entry?.mirror ? lockKey(spec.styleId, entry.mirror.sourceAssetId) : null,
       character: describeCharacter(spec, entry),
       outputs,
       quality,
@@ -10535,6 +10745,7 @@ async function buildGallerySnapshot(opts) {
       currentSpecHash: null,
       revision: entry.revision,
       revisionParentKey: entry.revision ? lockKey(entry.styleId, entry.revision.sourceAssetId) : null,
+      mirrorOfKey: entry.mirror ? lockKey(entry.styleId, entry.mirror.sourceAssetId) : null,
       character: describeCharacter(void 0, entry),
       outputs,
       quality: null,
@@ -10623,7 +10834,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path27.resolve(opts.lockPath),
+      lock: path28.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -10649,7 +10860,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path27.dirname(path27.resolve(opts.workspacePath));
+  const dir = path28.dirname(path28.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -10692,11 +10903,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path27.resolve(lockPath),
+        lock: path28.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await readFile16(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await readFile17(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -10708,8 +10919,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path27.resolve(lockPath),
-        root: path27.dirname(manifestPath),
+        lock: path28.resolve(lockPath),
+        root: path28.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -10736,7 +10947,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: path27.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: path28.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -10755,7 +10966,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 // src/gallery/server.ts
 import { randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
-import { readFile as readFile17 } from "fs/promises";
+import { readFile as readFile18 } from "fs/promises";
 
 // src/gallery/page.ts
 import { readFileSync as readFileSync4 } from "fs";
@@ -10996,7 +11207,7 @@ async function serveGallery(opts) {
         const asset = reviewAssets.get(jobId)?.get(url2.pathname);
         if (!asset) return fail(404, "no such review asset");
         try {
-          const bytes = await readFile17(asset.path);
+          const bytes = await readFile18(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -11072,7 +11283,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await readFile17(asset.path);
+          bytes = await readFile18(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -11216,7 +11427,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
   });
   const estimates = new Map(items.map((item) => [
     item.key,
-    validateCostEstimate(provider.id, provider.estimate(item.spec))
+    item.spec.mirror ? { amount: 0, unit: item.spec.costUnit, candidates: 1 } : validateCostEstimate(provider.id, provider.estimate(item.spec))
   ]));
   const units = new Set([...estimates.values()].map((estimate) => estimate.unit));
   if (units.size > 1) {
@@ -11266,6 +11477,34 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
   }
   for (const { spec, key } of items) {
     const estimate = estimates.get(key);
+    if (spec.mirror) {
+      try {
+        await requireRevisionReady(spec, lock);
+        await deriveMirror(spec, lock, lockPath, { onProgress: log2 });
+        submitted++;
+      } catch (err) {
+        const message6 = err instanceof Error ? err.message : String(err);
+        failed++;
+        upsert(lock, key, {
+          styleId: spec.styleId,
+          assetId: spec.assetId,
+          specHash: spec.specHash,
+          generator: spec.generator,
+          prompt: "",
+          width: spec.width,
+          height: spec.height,
+          status: "failed",
+          error: message6,
+          outputs: lock.entries[key]?.outputs ?? [],
+          cost: 0,
+          costUnit: spec.costUnit,
+          provider: provider.id
+        });
+        await saveLock(lockPath, lock);
+        log2(`  FAILED ${key}: ${message6}`);
+      }
+      continue;
+    }
     await waitForSlot();
     const since = Date.now() - lastSubmitAt;
     if (since < spacing) await sleep2(spacing - since);
@@ -11391,12 +11630,12 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
 
 // src/pick/server.ts
 import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile19 } from "fs/promises";
+import { readFile as readFile20 } from "fs/promises";
 
 // src/pipeline/init.ts
-import { readdir, readFile as readFile18, writeFile as writeFile11 } from "fs/promises";
+import { readdir, readFile as readFile19, writeFile as writeFile12 } from "fs/promises";
 import { existsSync as existsSync20 } from "fs";
-import path28 from "path";
+import path29 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -11410,7 +11649,7 @@ function slugify(value) {
 async function walk(dir, exclude) {
   const out = [];
   for (const entry of await readdir(dir, { withFileTypes: true })) {
-    const full = path28.join(dir, entry.name);
+    const full = path29.join(dir, entry.name);
     if (exclude.some((x) => full.includes(x))) continue;
     if (entry.isDirectory()) out.push(...await walk(full, exclude));
     else if (entry.name.toLowerCase().endsWith(".png")) out.push(full);
@@ -11424,14 +11663,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await readFile18(file));
+    const size = pngSize(await readFile19(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = path28.relative(root, file);
-    const category = path28.dirname(rel) === "." ? "" : path28.dirname(rel);
-    let id = slugify(path28.basename(rel));
+    const rel = path29.relative(root, file);
+    const category = path29.dirname(rel) === "." ? "" : path29.dirname(rel);
+    let id = slugify(path29.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -11492,7 +11731,7 @@ async function writeManifestFile(target, manifest) {
   if (existsSync20(target)) {
     throw new Error(`${target} already exists; refusing to overwrite an existing manifest.`);
   }
-  await writeFile11(target, JSON.stringify(manifest, null, 2) + "\n");
+  await writeFile12(target, JSON.stringify(manifest, null, 2) + "\n");
 }
 
 // src/pick/sheet.ts
@@ -11898,7 +12137,7 @@ async function currentArt(entry, spec) {
   let width = entry.width;
   let height = entry.height;
   if (contentType === "image/png") {
-    const size = pngSize(await readFile19(file));
+    const size = pngSize(await readFile20(file));
     if (size) ({ width, height } = size);
   }
   return { path: file, contentType, width, height };
@@ -12391,15 +12630,15 @@ function createGenerateHandlers(opts) {
 }
 
 // src/gallery/editor.ts
-import { readFile as readFile21 } from "fs/promises";
-import path30 from "path";
+import { readFile as readFile22 } from "fs/promises";
+import path31 from "path";
 
 // src/editor/install.ts
 import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir9, readFile as readFile20, rename as rename8, rm as rm9, stat as stat3, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile21, rename as rename9, rm as rm9, stat as stat3, writeFile as writeFile13 } from "fs/promises";
 import os2 from "os";
-import path29 from "path";
+import path30 from "path";
 
 // tools/pixelorama-bridge/pin.json
 var pin_default = {
@@ -12463,15 +12702,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return path29.resolve(override);
-  if (process.platform === "darwin") return path29.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return path30.resolve(override);
+  if (process.platform === "darwin") return path30.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return path29.join(process.env.LOCALAPPDATA ?? path29.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return path30.join(process.env.LOCALAPPDATA ?? path30.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return path29.join(process.env.XDG_CACHE_HOME ?? path29.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
+  return path30.join(process.env.XDG_CACHE_HOME ?? path30.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return path29.join(root, "pixelorama", pin.release ?? "unpublished");
+  return path30.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -12481,7 +12720,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash4("sha256").update(await readFile20(file)).digest("hex");
+    return createHash4("sha256").update(await readFile21(file)).digest("hex");
   } catch {
     return null;
   }
@@ -12494,7 +12733,7 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = path29.join(dir, name);
+    const file = path30.join(dir, name);
     const info = existsSync22(file) ? await stat3(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
@@ -12524,7 +12763,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await mkdir9(dir, { recursive: true });
+  await mkdir10(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -12552,11 +12791,11 @@ async function installEditor(opts = {}) {
     if (digest2 !== expected.sha256) {
       throw new EditorInstallError(`${name}: sha256 ${digest2.slice(0, 12)}\u2026 does not match the pinned ${expected.sha256.slice(0, 12)}\u2026`, name);
     }
-    const final = path29.join(dir, name);
+    const final = path30.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await writeFile12(tmp, bytes);
-      await rename8(tmp, final);
+      await writeFile13(tmp, bytes);
+      await rename9(tmp, final);
     } finally {
       await rm9(tmp, { force: true });
     }
@@ -12598,7 +12837,7 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[path29.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[path30.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
@@ -12674,7 +12913,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile21(path30.join(dir, name));
+        bytes = await readFile22(path31.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -12714,13 +12953,13 @@ async function serveUntilStopped(initial, reload, args, access2) {
   };
   const loadProject = async (project) => {
     const ctx = await access2.loadProject(project);
-    const dir = path31.dirname(ctx.loaded.path);
+    const dir = path32.dirname(ctx.loaded.path);
     const declared = readEnvFiles(dir);
     const credentialNames = new Set(availableProviders().flatMap((id) => providerCredentialEnvs(providerFactory(id))));
     for (const [name, value] of Object.entries(declared)) {
       if (credentialNames.has(name) && name in process.env && process.env[name] !== value) {
         throw new Error(
-          `${path31.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
+          `${path32.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
         );
       }
     }
@@ -12765,7 +13004,7 @@ async function serveUntilStopped(initial, reload, args, access2) {
 }
 async function runGallery(args) {
   if (args.workspace) {
-    const workspacePath = path31.resolve(args.workspace);
+    const workspacePath = path32.resolve(args.workspace);
     if (!existsSync23(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
@@ -12786,7 +13025,7 @@ async function runGallery(args) {
     const registered = async (projectId) => {
       const project = (await loadWorkspace(workspacePath)).projects.find((candidate) => candidate.id === projectId);
       if (!projectId || !project) throw new Error(`unknown workspace project "${projectId ?? ""}"`);
-      return resolveProject(path31.dirname(workspacePath), project);
+      return resolveProject(path32.dirname(workspacePath), project);
     };
     await serveUntilStopped(initial, build2, args, {
       manifestFor: async (projectId) => (await registered(projectId)).manifestPath,
@@ -12811,7 +13050,7 @@ async function runGallery(args) {
     return buildGallerySnapshot({ ...fresh, filter });
   };
   await serveUntilStopped(await build(), reload, args, {
-    manifestFor: () => path31.resolve(args.manifest),
+    manifestFor: () => path32.resolve(args.manifest),
     loadProject: () => openProject(args.manifest, { lockPath: args.lock, env: false })
   });
 }
@@ -13054,7 +13293,7 @@ async function runLifecycle(args, wave, spent) {
         log(`  Packaging stays blocked until each refined PNG has a current human approval.`);
       }
     }
-    return args.command === "gen" && submitted > 0 && total.downloaded > 0 && !total.failed && specs.some((spec) => spec.character?.parentSpec || spec.revision);
+    return args.command === "gen" && submitted > 0 && total.downloaded > 0 && !total.failed && specs.some((spec) => spec.character?.parentSpec || spec.revision || spec.mirror);
   }
   return false;
 }
@@ -13120,14 +13359,14 @@ import { existsSync as existsSync25 } from "fs";
 
 // src/pipeline/cache-health.ts
 import { existsSync as existsSync24 } from "fs";
-import { readFile as readFile22, readdir as readdir2, rm as rm10 } from "fs/promises";
-import path32 from "path";
+import { readFile as readFile23, readdir as readdir2, rm as rm10 } from "fs/promises";
+import path33 from "path";
 async function inspectCaches(lock, lockPath, options = {}) {
   if (options.prune && !existsSync24(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path32.resolve(lockPath)}`);
+    throw new Error(`Refusing to prune without an existing lockfile at ${path33.resolve(lockPath)}`);
   }
-  const contentDir = path32.resolve(path32.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path32.resolve(cachePathFor(lockPath));
+  const contentDir = path33.resolve(path33.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path33.resolve(cachePathFor(lockPath));
   const referenced = referencedHashes(lock);
   let content = await inspectContentCache(contentDir, referenced);
   let remoteHashes = await inspectRemoteHashCache(remotePath);
@@ -13139,7 +13378,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm10(path32.join(contentDir, name), { force: true });
+        await rm10(path33.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -13148,7 +13387,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 readFile22(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile23(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -13187,12 +13426,12 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path32.join(contentDir, entry.name);
+    const file = path33.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile22(file);
+      bytes = await readFile23(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -13239,7 +13478,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile22(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile23(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -13358,42 +13597,42 @@ This drops their provenance from the lockfile. The art on disk is`);
 }
 
 // src/cli/commands/init.ts
-import path33 from "path";
+import path34 from "path";
 import { existsSync as existsSync26 } from "fs";
 async function runInit(args) {
   if (!args.from) throw new Error("init needs --from <dir> pointing at your existing PNGs.");
-  const root = path33.resolve(args.from);
+  const root = path34.resolve(args.from);
   if (!existsSync26(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 = path33.resolve(args.out ?? "pixelkiln.manifest.json");
+  const target = path34.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 ?? path33.basename(path33.dirname(target)),
+    args.name ?? path34.basename(path34.dirname(target)),
     args.styles[0] ?? "base",
     generator,
-    path33.relative(path33.dirname(target), root) || ".",
+    path34.relative(path34.dirname(target), root) || ".",
     assets
   );
   await writeManifestFile(target, manifest);
-  log(`  scanned ${assets.length} PNG(s) under ${path33.relative(process.cwd(), root)}`);
+  log(`  scanned ${assets.length} PNG(s) under ${path34.relative(process.cwd(), root)}`);
   if (skipped.length) log(`  skipped ${skipped.length} unreadable file(s)`);
-  log(`  wrote ${path33.relative(process.cwd(), target)}`);
+  log(`  wrote ${path34.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 ${path33.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path34.relative(process.cwd(), target)} --write-prompts
 `);
 }
 
 // src/pipeline/doctor.ts
 import { constants, existsSync as existsSync27 } from "fs";
 import { access, stat as stat4 } from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message6) => checks.push({ id, level, message: message6 });
@@ -13404,8 +13643,8 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   );
   add("lock", "ok", `${Object.keys(lock.entries).length} valid v2 lock entr(ies)`);
   const dirs = [...new Set(specs.flatMap((spec) => [
-    path34.dirname(spec.outFile),
-    ...spec.quality ? [path34.dirname(spec.quality.outFile)] : []
+    path35.dirname(spec.outFile),
+    ...spec.quality ? [path35.dirname(spec.quality.outFile)] : []
   ]))];
   const unwritable = [];
   for (const dir of dirs) {
@@ -13428,7 +13667,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     for (let index = 0; index < entry.outputs.length; index++) {
       const output = entry.outputs[index];
       const spec = specByKey.get(key);
-      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path34.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path35.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -13443,7 +13682,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   } else {
     add("lock-outputs", "ok", `${outputOwners.size} recorded output path(s) are uniquely owned`);
   }
-  const cacheDir = path34.join(path34.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = path35.join(path35.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -13459,7 +13698,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     const hasSource = Boolean(entry.sourceUrl || entry.sourceUrls?.length);
     let hasCache = false;
     for (const output of entry.outputs) {
-      const cached = path34.join(
+      const cached = path35.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
@@ -13559,16 +13798,16 @@ async function nearestExistingDirectory(start) {
       if ((await stat4(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = path34.dirname(current);
+    const parent = path35.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
 }
 
 // src/pipeline/audit.ts
-import { readFile as readFile23 } from "fs/promises";
+import { readFile as readFile24 } from "fs/promises";
 import { existsSync as existsSync28 } from "fs";
-import path35 from "path";
+import path36 from "path";
 function paletteDistance(asset, reference) {
   if (!asset.length || !reference.length) return 0;
   let total = 0;
@@ -13609,7 +13848,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
         continue;
       }
       try {
-        const png = decodePng(await readFile23(output.absolutePath));
+        const png = decodePng(await readFile24(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -13633,10 +13872,10 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = path35.resolve(loaded.root, img.path);
+    const abs = path36.resolve(loaded.root, img.path);
     if (!existsSync28(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await readFile23(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await readFile24(abs)), 12));
     } catch {
     }
   }
@@ -13856,24 +14095,24 @@ async function runAudit(args) {
 }
 
 // src/cli/commands/pack.ts
-import path37 from "path";
-import { readFile as readFile24 } from "fs/promises";
+import path38 from "path";
+import { readFile as readFile25 } from "fs/promises";
 
 // src/pipeline/pack.ts
 import { readFileSync as readFileSync5 } from "fs";
-import path36 from "path";
+import path37 from "path";
 var DEFAULT_FRAME_SET_FPS = 12;
 function resolvePackInputs(raw, inputsFilePath) {
   if (!Array.isArray(raw) || !raw.length) {
     throw new Error("--inputs must be a non-empty JSON array of { id, path }");
   }
-  const baseDir = path36.dirname(path36.resolve(inputsFilePath));
+  const baseDir = path37.dirname(path37.resolve(inputsFilePath));
   return raw.map((entry, i) => {
     const e = entry;
     if (typeof e.id !== "string" || typeof e.path !== "string") {
       throw new Error(`--inputs[${i}] needs string "id" and "path"`);
     }
-    return { id: e.id, path: path36.resolve(baseDir, e.path) };
+    return { id: e.id, path: path37.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -13945,7 +14184,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
     const inputs2 = Object.entries(options.sourceOverrides).map(([id, source]) => ({
       id,
-      path: path36.resolve(source)
+      path: path37.resolve(source)
     }));
     if (!inputs2.length) throw new Error(`No approved quality outputs for style "${styleId}".`);
     const packed2 = packSprites(inputs2, options);
@@ -13969,7 +14208,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     let outputs = resolveEntryOutputs(entry, id, manifestDir);
     const source = sources[id];
     if (source && outputs.length <= 1) {
-      inputs.push({ id, path: path36.resolve(manifestDir, source) });
+      inputs.push({ id, path: path37.resolve(manifestDir, source) });
       continue;
     }
     if (source && sourceIsStem(source, entry, manifestDir)) {
@@ -14003,7 +14242,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
   }
   for (const [id, source] of Object.entries(sources)) {
-    if (!locked.has(id)) inputs.push({ id, path: path36.resolve(manifestDir, source) });
+    if (!locked.has(id)) inputs.push({ id, path: path37.resolve(manifestDir, source) });
   }
   if (!inputs.length) {
     throw new Error(`No readable sprites for style "${styleId}"; ${noOutput.length} skipped.`);
@@ -14111,7 +14350,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     const source = sources[id];
     const entry = lock.entries[`${styleId}/${id}`];
     if (source && !(entry && sourceIsStem(source, entry, manifestDir))) {
-      placements.push({ id, path: path36.resolve(manifestDir, source), cell });
+      placements.push({ id, path: path37.resolve(manifestDir, source), cell });
       continue;
     }
     if (source && entry) {
@@ -14144,7 +14383,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
       `Nothing to mount for style "${styleId}": ${ids.length} asset(s) declare a cell, but none has generated output or a \`source\`. Run \`pixelkiln gen --style ${styleId}\`, or point each at a file.${detail}`
     );
   }
-  const basePng = mount.base ? readFileSync5(path36.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? readFileSync5(path37.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -14154,7 +14393,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: path36.resolve(manifestDir, mount.base),
+      path: path37.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -14521,12 +14760,12 @@ async function runPack(args) {
     if (args.primaryOnly || args.outputRoles.length) {
       throw new Error("--primary-only and --output-role require manifest-driven pack");
     }
-    const raw = JSON.parse(await readFile24(path37.resolve(args.inputs), "utf8"));
+    const raw = JSON.parse(await readFile25(path38.resolve(args.inputs), "utf8"));
     const inputs = resolvePackInputs(raw, args.inputs);
     const { png, atlas, skipped, sources } = packSprites(inputs, { columns: args.columns });
     const format = sheetFormat(args);
-    const base = path37.resolve(args.out.replace(/\.(?:png|json|tres)$/i, ""));
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path37.basename(`${base}.png`) });
+    const base = path38.resolve(args.out.replace(/\.(?:png|json|tres)$/i, ""));
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path38.basename(`${base}.png`) });
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}${extension}`, data: document }
@@ -14539,7 +14778,7 @@ async function runPack(args) {
     log(
       `  ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s), ${(png.length / 1024).toFixed(1)} KB (${format})`
     );
-    log(`    ${path37.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
+    log(`    ${path38.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     return;
   }
@@ -14547,7 +14786,7 @@ async function runPack(args) {
   if (args.primaryOnly && args.outputRoles.length) {
     throw new Error("pack accepts either --primary-only or --output-role, not both");
   }
-  const manifestDir = path37.dirname(path37.resolve(args.manifest));
+  const manifestDir = path38.dirname(path38.resolve(args.manifest));
   const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
   for (const styleId of styleIds) {
     const packagingSpecs = await resolveSpecs(loaded, { styles: [styleId] });
@@ -14560,9 +14799,9 @@ async function runPack(args) {
       sources: manifestSources(loaded.manifest, styleId)
     });
     const style = loaded.manifest.styles[styleId];
-    const base = args.out ? path37.resolve(args.out.replace(/\.(?:png|json|tres)$/i, "")) : path37.resolve(manifestDir, style.outDir, `${styleId}-sheet`);
+    const base = args.out ? path38.resolve(args.out.replace(/\.(?:png|json|tres)$/i, "")) : path38.resolve(manifestDir, style.outDir, `${styleId}-sheet`);
     const format = sheetFormat(args);
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path37.basename(`${base}.png`) });
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path38.basename(`${base}.png`) });
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}${extension}`, data: document }
@@ -14593,13 +14832,13 @@ async function runPack(args) {
     log(
       `  ${styleId}: ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s)` + (atlas.sets?.length ? `, ${atlas.sets.length} set(s)` : "") + ` (${format})`
     );
-    log(`    ${path37.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
+    log(`    ${path38.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
   }
 }
 async function runMount(args) {
   const { loaded, lock } = await openProject2(args);
-  const manifestDir = path37.dirname(path37.resolve(args.manifest));
+  const manifestDir = path38.dirname(path38.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];
@@ -14638,9 +14877,9 @@ async function runMount(args) {
       sources,
       outputRoles
     );
-    const out = path37.resolve(manifestDir, style.mount.out);
+    const out = path38.resolve(manifestDir, style.mount.out);
     const format = sheetFormat(args);
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path37.basename(out) });
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path38.basename(out) });
     const metadata = out.replace(/\.png$/, "") + extension;
     const companion = out.replace(/\.png$/, "") + ".pixelkiln.json";
     const outputs = [
@@ -14660,7 +14899,7 @@ async function runMount(args) {
         await provenanceFile("$lock", args.lock),
         ...qualityRecords,
         ...artifactSources.filter(
-          (source) => source.id !== "$base" || path37.resolve(source.path) !== out
+          (source) => source.id !== "$base" || path38.resolve(source.path) !== out
         )
       ],
       options: {
@@ -14674,14 +14913,14 @@ async function runMount(args) {
     log(
       `  ${styleId}: ${atlas.frames.length} cell(s) into ${atlas.sheet.width}x${atlas.sheet.height}` + (overBase ? ` over ${style.mount.base}` : " (new sheet)")
     );
-    log(`    ${path37.relative(process.cwd(), out)} + atlas/provenance JSON`);
+    log(`    ${path38.relative(process.cwd(), out)} + atlas/provenance JSON`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
   }
 }
 async function runExport(args) {
   const { loaded, specs, lock } = await openProject2(args);
   const format = args.format ?? "generic";
-  const manifestDir = path37.dirname(path37.resolve(args.manifest));
+  const manifestDir = path38.dirname(path38.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;
@@ -14697,12 +14936,12 @@ async function runExport(args) {
   for (const spec of selected) {
     const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
     const style = loaded.manifest.styles[spec.styleId];
-    const defaultBase = path37.resolve(manifestDir, style.outDir, `${spec.assetId}-tileset`);
-    const base = args.out ? path37.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
+    const defaultBase = path38.resolve(manifestDir, style.outDir, `${spec.assetId}-tileset`);
+    const base = args.out ? path38.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
     const result = exportTileset(entry, spec, {
       format,
       manifestDir,
-      imageName: path37.basename(`${base}.png`),
+      imageName: path38.basename(`${base}.png`),
       columns: args.columns
     });
     const outputs = [
@@ -14720,7 +14959,7 @@ async function runExport(args) {
         asset: spec.assetId,
         columns: args.columns ?? null,
         format,
-        image: path37.basename(`${base}.png`),
+        image: path38.basename(`${base}.png`),
         providerRules: result.generic.providerRules,
         style: spec.styleId,
         tileType: spec.tileType ?? null
@@ -14730,7 +14969,7 @@ async function runExport(args) {
       `  ${spec.styleId}/${spec.assetId}: ${result.generic.tiles.length} tile(s), ${result.generic.sheet.width}x${result.generic.sheet.height} (${format})`
     );
     log(
-      `    ${path37.relative(process.cwd(), base)}.png + ${path37.basename(base)}${result.extension} + .pixelkiln.json`
+      `    ${path38.relative(process.cwd(), base)}.png + ${path38.basename(base)}${result.extension} + .pixelkiln.json`
     );
   }
 }
@@ -14743,19 +14982,19 @@ function sheetFormat(args) {
 }
 
 // src/cli/commands/quality.ts
-import path39 from "path";
-import { readFile as readFile26 } from "fs/promises";
+import path40 from "path";
+import { readFile as readFile27 } from "fs/promises";
 
 // src/pipeline/quality-regression.ts
-import path38 from "path";
+import path39 from "path";
 import { existsSync as existsSync29 } from "fs";
-import { readFile as readFile25 } from "fs/promises";
+import { readFile as readFile26 } from "fs/promises";
 import { z as z9 } from "zod";
 var SHA256_RE = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
 var QualityPathSchema = z9.string().min(1).refine(
-  (value) => !path38.posix.isAbsolute(value) && !value.includes("\\"),
+  (value) => !path39.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -14902,10 +15141,10 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = path38.resolve(file);
+  const absolute = path39.resolve(file);
   let bytes;
   try {
-    bytes = await readFile25(absolute);
+    bytes = await readFile26(absolute);
   } catch (error) {
     throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -14924,11 +15163,11 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }
   const ids = parsed.data.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) throw new Error("--inputs contains a duplicate quality case id.");
-  const root = path38.dirname(path38.resolve(inputsFilePath));
+  const root = path39.dirname(path39.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: path38.resolve(root, entry.path),
-    ...entry.record ? { record: path38.resolve(root, entry.record) } : {},
+    file: path39.resolve(root, entry.path),
+    ...entry.record ? { record: path39.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -14936,7 +15175,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return path38.relative(from, path38.resolve(to)).split(path38.sep).join("/") || ".";
+  return path39.relative(from, path39.resolve(to)).split(path39.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -14951,20 +15190,20 @@ async function verifyRecordForImage(recordPath, imagePath) {
   if (record.kind !== "refine" || options === null || typeof options !== "object" || options.schema !== "pixelkiln-quality") {
     throw new Error(`Quality record ${recordPath} is not a PixelKiln refinement record.`);
   }
-  const outputs = record.outputs.map((output) => path38.resolve(path38.dirname(recordPath), output.path));
-  if (!outputs.includes(path38.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => path39.resolve(path39.dirname(recordPath), output.path));
+  if (!outputs.includes(path39.resolve(imagePath))) {
     throw new Error(`Quality record ${recordPath} does not own ${imagePath}.`);
   }
 }
 async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   if (!inputs.length) throw new Error("Cannot snapshot an empty quality baseline.");
-  const absolute = path38.resolve(baselinePath);
+  const absolute = path39.resolve(baselinePath);
   for (const input of inputs) {
-    if (path38.resolve(input.file) === absolute || input.record && path38.resolve(input.record) === absolute) {
+    if (path39.resolve(input.file) === absolute || input.record && path39.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = path38.dirname(absolute);
+  const root = path39.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -14992,7 +15231,7 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
   if (existsSync29(absolute) && !options.force) {
-    const current = await readFile25(absolute);
+    const current = await readFile26(absolute);
     if (!current.equals(data)) {
       throw new OverwriteRefusedError(
         `Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`,
@@ -15004,10 +15243,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = path38.resolve(baselinePath);
+  const absolute = path39.resolve(baselinePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile25(absolute, "utf8"));
+    raw = JSON.parse(await readFile26(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -15077,12 +15316,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = path38.resolve(baselinePath);
+  const absolute = path39.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = path38.dirname(absolute);
+  const root = path39.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = path38.resolve(root, entry.file);
+    const file = path39.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -15095,7 +15334,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = path38.resolve(root, entry.record.path);
+      const recordPath = path39.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -15137,15 +15376,15 @@ async function runQuality(args) {
     if (!args.out) throw new Error("quality snapshot needs --out <pixelkiln.quality.json>.");
     let raw;
     try {
-      raw = JSON.parse(await readFile26(path39.resolve(args.inputs), "utf8"));
+      raw = JSON.parse(await readFile27(path40.resolve(args.inputs), "utf8"));
     } catch (error) {
       throw new Error(
-        `Could not read quality inputs ${path39.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
+        `Could not read quality inputs ${path40.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
         { cause: error }
       );
     }
     const inputs = resolveQualityInputs(raw, args.inputs);
-    if (path39.resolve(args.inputs) === path39.resolve(args.out)) {
+    if (path40.resolve(args.inputs) === path40.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 });
@@ -15158,7 +15397,7 @@ async function runQuality(args) {
       }, null, 2));
     } else {
       log(
-        `  ${result.changed ? "wrote" : "unchanged"} ${path39.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
+        `  ${result.changed ? "wrote" : "unchanged"} ${path40.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
       );
       log(`  Review the tolerances, commit the baseline, then run quality check in CI.`);
     }
@@ -15184,12 +15423,12 @@ async function runQuality(args) {
 }
 
 // src/cli/commands/recipe.ts
-import path41 from "path";
+import path42 from "path";
 
 // src/recipes.ts
-import path40 from "path";
+import path41 from "path";
 import { existsSync as existsSync30 } from "fs";
-import { readdir as readdir3, readFile as readFile27 } from "fs/promises";
+import { readdir as readdir3, readFile as readFile28 } from "fs/promises";
 import { fileURLToPath } from "url";
 import { z as z10 } from "zod";
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
@@ -15198,7 +15437,7 @@ var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
 var PortablePathSchema = z10.string().min(1).refine((value) => {
-  if (value.includes("\\") || path40.posix.isAbsolute(value)) return false;
+  if (value.includes("\\") || path41.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
@@ -15374,10 +15613,10 @@ function message5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path40.resolve(recipePath);
+  const absolute = path41.resolve(recipePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile27(absolute, "utf8"));
+    raw = JSON.parse(await readFile28(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read recipe ${absolute}: ${message5(error)}`, { cause: error });
   }
@@ -15388,13 +15627,13 @@ async function readRecipeFile(recipePath, bundled) {
 ` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
     );
   }
-  return { recipe: parsed.data, authored: raw, path: absolute, dir: path40.dirname(absolute), bundled };
+  return { recipe: parsed.data, authored: raw, path: absolute, dir: path41.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
   if (!existsSync30(root)) return [];
   const out = [];
   for (const entry of await readdir3(root, { withFileTypes: true })) {
-    const resolved = path40.join(root, entry.name);
+    const resolved = path41.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -15405,7 +15644,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path40.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path41.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)
@@ -15428,9 +15667,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path40.resolve(target);
+  const local = path41.resolve(target);
   if (existsSync30(local)) {
-    const recipePath = path40.basename(local) === RECIPE_FILE ? local : path40.join(local, RECIPE_FILE);
+    const recipePath = path41.basename(local) === RECIPE_FILE ? local : path41.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -15444,7 +15683,7 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path40.resolve(root, ...file.path.split("/"));
+  const absolute = path41.resolve(root, ...file.path.split("/"));
   if (!existsSync30(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
@@ -15460,7 +15699,7 @@ async function verifyRecipe(target, options = {}) {
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const actualIntegrity = recipeDigest(loaded.authored);
   const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
-  const modelRoot = options.modelRoot ? path40.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path41.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -15494,7 +15733,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path40.relative(cwd, destination).split(path40.sep).join("/") || ".";
+  const portableDir = path41.relative(cwd, destination).split(path41.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -15506,25 +15745,25 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path40.resolve(options.cwd ?? process.cwd());
+  const cwd = path41.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 ? path40.resolve(cwd, options.out) : path40.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path41.resolve(cwd, options.out) : path41.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: path40.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path41.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path40.join(destination, ...file.path.split("/")),
-    data: await readFile27(file.source)
+    path: path41.join(destination, ...file.path.split("/")),
+    data: await readFile28(file.source)
   })));
   if (!options.force) {
     for (const file of files) {
       if (!existsSync30(file.path)) continue;
-      const current = await readFile27(file.path);
+      const current = await readFile28(file.path);
       if (!current.equals(file.data)) {
         throw new OverwriteRefusedError(
           `Recipe destination has local changes: ${file.path}. Choose another --out or pass --force to replace declared recipe files.`,
@@ -15618,14 +15857,14 @@ async function runRecipe(args) {
       }, null, 2));
     } else {
       log(`  installed ${result.recipe.id}@${result.recipe.version}`);
-      log(`  ${path41.relative(process.cwd(), result.destination) || "."}`);
+      log(`  ${path42.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 ${path41.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
+        log(`  pixelkiln recipe verify ${path42.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
       }
     }
     return;
@@ -15633,7 +15872,7 @@ async function runRecipe(args) {
 }
 
 // src/cli/commands/refine.ts
-import path42 from "path";
+import path43 from "path";
 async function runRefine(args) {
   if (args.from || args.subcommand === "approve") {
     if (!args.from) {
@@ -15663,12 +15902,12 @@ async function runRefine(args) {
           `  recovered ${result3.detection.columns}x${result3.detection.rows} native grid (${result3.detection.confidence}: ${result3.detection.consensus})`
         );
         log(`  enforced ${result3.palette.length}-color palette without dithering`);
-        log(`  wrote ${path42.relative(process.cwd(), result3.output)}`);
-        log(`  quality record: ${path42.relative(process.cwd(), result3.record)}`);
+        log(`  wrote ${path43.relative(process.cwd(), result3.output)}`);
+        log(`  quality record: ${path43.relative(process.cwd(), result3.record)}`);
         log(`
   Automated checks passed. Human 1\xD7 review is still required:`);
         log(
-          `    pixelkiln refine approve --from ${path42.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path43.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
         );
       }
       return;
@@ -15696,7 +15935,7 @@ async function runRefine(args) {
       if (args.json) log(JSON.stringify(result3, null, 2));
       else {
         log(
-          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path42.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path42.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
+          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path43.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path43.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
         );
       }
       return;
@@ -15705,7 +15944,7 @@ async function runRefine(args) {
     if (args.json) {
       log(JSON.stringify(result2, null, 2));
     } else {
-      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path42.relative(process.cwd(), result2.output || result2.record)}`);
+      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path43.relative(process.cwd(), result2.output || result2.record)}`);
       for (const reason of result2.reasons) log(`    ${reason}`);
     }
     if (!result2.safe) process.exitCode = 1;
@@ -15751,7 +15990,7 @@ async function runRefine(args) {
       log(`  ${item.state.padEnd(16)} ${item.key}  ${item.reason}`);
       if (item.state === "needs-approval") {
         log(
-          `    pixelkiln refine approve --from ${path42.relative(process.cwd(), item.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path43.relative(process.cwd(), item.record)} --reviewer "Your Name"`
         );
       }
     }
@@ -15803,15 +16042,15 @@ async function runTools(args) {
 }
 
 // src/cli/commands/workspace.ts
-import path43 from "path";
+import path44 from "path";
 import { existsSync as existsSync31 } from "fs";
 async function runWorkspace(args) {
-  const workspacePath = path43.resolve(args.workspace ?? "pixelkiln.workspace.json");
-  const dir = path43.dirname(workspacePath);
+  const workspacePath = path44.resolve(args.workspace ?? "pixelkiln.workspace.json");
+  const dir = path44.dirname(workspacePath);
   if (args.subcommand === "add") {
-    const manifestPath = path43.resolve(args.target);
+    const manifestPath = path44.resolve(args.target);
     const loadedTarget = await loadManifest(manifestPath);
-    const lockPath = args.explicitLock ? path43.resolve(args.explicitLock) : path43.join(path43.dirname(manifestPath), "pixelkiln.lock.json");
+    const lockPath = args.explicitLock ? path44.resolve(args.explicitLock) : path44.join(path44.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)) {
@@ -15831,7 +16070,7 @@ async function runWorkspace(args) {
       ...args.account ? { account: args.account } : {}
     };
     await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-    log(`  registered "${id}" in ${path43.relative(process.cwd(), workspacePath)}`);
+    log(`  registered "${id}" in ${path44.relative(process.cwd(), workspacePath)}`);
     log(`    manifest: ${project.manifest}`);
     log(`    lock:     ${project.lock}`);
     if (!existsSync31(lockPath)) {
@@ -15843,7 +16082,7 @@ async function runWorkspace(args) {
   }
   if (args.subcommand === "remove") {
     const ws = await loadWorkspace(workspacePath);
-    const resolvedTarget = path43.resolve(args.target);
+    const resolvedTarget = path44.resolve(args.target);
     const match = ws.projects.find(
       (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
     );
@@ -15854,7 +16093,7 @@ async function runWorkspace(args) {
       version: 1,
       projects: ws.projects.filter((p) => p !== match)
     });
-    log(`  removed "${match.id}" from ${path43.relative(process.cwd(), workspacePath)}`);
+    log(`  removed "${match.id}" from ${path44.relative(process.cwd(), workspacePath)}`);
     return;
   }
   if (args.subcommand === "list") {
@@ -15866,9 +16105,9 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ version: 1, workspace: workspacePath, projects: ws.projects, diagnostics }, null, 2));
     } else if (!ws.projects.length) {
-      log(`  no projects registered in ${path43.relative(process.cwd(), workspacePath)}`);
+      log(`  no projects registered in ${path44.relative(process.cwd(), workspacePath)}`);
     } else {
-      log(`  ${ws.projects.length} project(s) in ${path43.relative(process.cwd(), workspacePath)}:`);
+      log(`  ${ws.projects.length} project(s) in ${path44.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}` : ""})`);
       }
@@ -15886,7 +16125,7 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
     } else {
-      log(`  workspace: ${path43.relative(process.cwd(), workspacePath)}`);
+      log(`  workspace: ${path44.relative(process.cwd(), workspacePath)}`);
       for (const p of report.projects) {
         if (p.error) {
           log(`
@@ -15941,7 +16180,7 @@ async function runVersion() {
   for (const up of ["../package.json", "../../package.json"]) {
     const url = new URL(up, import.meta.url);
     if (!existsSync32(url)) continue;
-    const pkg = JSON.parse(await readFile28(url, "utf8"));
+    const pkg = JSON.parse(await readFile29(url, "utf8"));
     if (pkg.name === "pixelkiln") {
       log(`${pkg.name} ${pkg.version}`);
       return;