pixelkiln 0.28.0 → 0.30.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import path30 from "path";
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { readFile as readFile25 } from "fs/promises";
 
 // src/env.ts
@@ -872,12 +872,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
   }
   validate(spec, styleImages) {
     const options = resolvedOptions(spec);
-    if (spec.source && !spec.revision) {
-      if (spec.generator === "frames") {
-        throw new Error("ComfyUI frame sets require generated provider outputs, not asset.source");
-      }
-      return;
-    }
+    if (spec.source && !spec.revision && spec.generator !== "frames") return;
     if (spec.width < 16 || spec.height < 16 || spec.width > 4096 || spec.height > 4096) {
       throw new Error("ComfyUI output dimensions must be between 16 and 4096 pixels");
     }
@@ -3483,10 +3478,11 @@ registerProvider({
 
 // src/manifest.ts
 import { readFile as readFile3 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import path6 from "path";
 
 // src/outputs.ts
+import { existsSync as existsSync4 } from "fs";
 import path5 from "path";
 
 // src/lock.ts
@@ -3673,13 +3669,28 @@ function resolveOutputPath(recordedPath, manifestDir) {
   return path5.resolve(manifestDir, recordedPath.split(/[\\/]/).join(path5.sep));
 }
 function expectedOutputPath(spec, role, index, total, mediaType) {
-  const originalExt = path5.extname(spec.outFile);
+  return memberPath(spec.outFile, role, index, total, mediaType);
+}
+function memberPath(file, role, index, total, mediaType) {
+  const originalExt = path5.extname(file);
   const ext = mediaType ? mediaExtension(mediaType) : originalExt || ".png";
-  const stem = originalExt ? spec.outFile.slice(0, -originalExt.length) : spec.outFile;
+  const stem = originalExt ? file.slice(0, -originalExt.length) : file;
   if (total === 1) return `${stem}${ext}`;
   const safeRole = (role ?? fallbackOutputRole(index)).replace(/[^a-zA-Z0-9_-]+/g, "-");
   return `${stem}-${safeRole}${ext}`;
 }
+function isMemberSetEntry(entry) {
+  return entry.outputs.length > 1 && entry.outputs.every((output) => !output.mediaType || output.mediaType === "image/png");
+}
+function sourceIsStem(source, entry, manifestDir) {
+  return isMemberSetEntry(entry) && !existsSync4(path5.resolve(manifestDir, source));
+}
+function sourceOutputPath(source, entry, index, manifestDir) {
+  const absolute = path5.resolve(manifestDir, source);
+  if (!sourceIsStem(source, entry, manifestDir)) return absolute;
+  const output = entry.outputs[index];
+  return memberPath(absolute, output.role, index, entry.outputs.length, output.mediaType);
+}
 function currentOutputPath(output, spec, index, total) {
   return expectedOutputPath(spec, output.role, index, total, output.mediaType);
 }
@@ -3764,7 +3775,7 @@ function resolveSpecOutputs(spec, lock, manifestDir) {
 // src/manifest.ts
 async function loadManifest(manifestPath) {
   const abs = path6.resolve(manifestPath);
-  if (!existsSync4(abs)) throw new Error(`No manifest at ${abs}`);
+  if (!existsSync5(abs)) throw new Error(`No manifest at ${abs}`);
   const input = ManifestInputSchema.safeParse(JSON.parse(await readFile3(abs, "utf8")));
   if (!input.success) {
     const issues = formatManifestIssues(input.error.issues);
@@ -3936,7 +3947,7 @@ async function resolveSpecs(loaded, filter) {
     const abs = path6.resolve(root, rel);
     let hit = styleImageCache.get(abs);
     if (!hit) {
-      if (!existsSync4(abs)) throw new Error(`Style image not found: ${abs}`);
+      if (!existsSync5(abs)) throw new Error(`Style image not found: ${abs}`);
       const buf = await readFile3(abs);
       const metadata = imageMetadata(buf);
       if (!metadata) throw new Error(`Style image is not a readable PNG or JPEG: ${abs}`);
@@ -4177,7 +4188,7 @@ function pngPath(file) {
   return extension ? `${file.slice(0, -extension.length)}.png` : `${file}.png`;
 }
 async function optionalRevisionImage(file, label, requiredFormat) {
-  if (!existsSync4(file)) return null;
+  if (!existsSync5(file)) return null;
   const bytes = await readFile3(file);
   const metadata = imageMetadata(bytes);
   if (!metadata) throw new Error(`${label} is not a readable PNG or JPEG: ${file}`);
@@ -4336,12 +4347,15 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
   for (const [key, entry] of entries) {
     const id = key.slice(prefix.length);
     locked.add(id);
-    const outputs = resolveEntryOutputs(entry, id, manifestDir);
+    let outputs = resolveEntryOutputs(entry, id, manifestDir);
     const source = sources[id];
     if (source && outputs.length <= 1) {
       inputs.push({ id, path: path7.resolve(manifestDir, source) });
       continue;
     }
+    if (source && sourceIsStem(source, entry, manifestDir)) {
+      outputs = outputs.map((output) => ({ ...output, absolutePath: sourceOutputPath(source, entry, output.index, manifestDir) }));
+    }
     let selected = outputs;
     if (options.outputRoles?.length) {
       selected = outputs.filter(
@@ -4463,11 +4477,21 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
   for (const id of ids) {
     const cell = cells[id];
     const source = sources[id];
-    if (source) {
+    const entry = lock.entries[`${styleId}/${id}`];
+    if (source && !(entry && sourceIsStem(source, entry, manifestDir))) {
       placements.push({ id, path: path7.resolve(manifestDir, source), cell });
       continue;
     }
-    const entry = lock.entries[`${styleId}/${id}`];
+    if (source && entry) {
+      const selection2 = selectEntryOutput(entry, outputRoles[id]);
+      if (!selection2.ok) {
+        skipped.push({ id, reason: selection2.reason });
+        continue;
+      }
+      const index = entry.outputs.findIndex((output) => output.path === selection2.output.path);
+      placements.push({ id, path: sourceOutputPath(source, entry, Math.max(index, 0), manifestDir), cell });
+      continue;
+    }
     if (!entry) {
       skipped.push({
         id,
@@ -4508,11 +4532,11 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
 }
 
 // src/pipeline/plan.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import path13 from "path";
 
 // src/pipeline/quality-profile.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import path11 from "path";
 
 // src/pipeline/refine.ts
@@ -4980,7 +5004,7 @@ async function writeArtifactBundle(files, options = {}) {
 
 // src/pipeline/audit.ts
 import { readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import path9 from "path";
 function colorDistance(a, b) {
   const rmean = (a.r + b.r) / 2;
@@ -5026,7 +5050,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
   const unreadable = [];
   for (const spec of mine) {
     for (const output of resolveSpecOutputs(spec, lock, loaded.root)) {
-      if (!existsSync5(output.absolutePath)) {
+      if (!existsSync6(output.absolutePath)) {
         missing.push(output.id);
         continue;
       }
@@ -5056,7 +5080,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
   const refPalettes = [];
   for (const img of style.styleImages) {
     const abs = path9.resolve(loaded.root, img.path);
-    if (!existsSync5(abs)) continue;
+    if (!existsSync6(abs)) continue;
     try {
       refPalettes.push(extractPalette(decodePng(await readFile5(abs)), 12));
     } catch {
@@ -5685,7 +5709,7 @@ async function qualitySource(spec, lock) {
       return { items: null, reason: "frame-set quality requires ordered downloaded provider outputs" };
     }
     const source = path11.resolve(spec.root, spec.source);
-    return existsSync6(source) ? { items: [{ role: "source", path: source }] } : { items: null, reason: `declared source is missing: ${spec.source}` };
+    return existsSync7(source) ? { items: [{ role: "source", path: source }] } : { items: null, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
   if (!entry) return { items: null, reason: "raw provider output is not in the lockfile" };
@@ -5714,7 +5738,7 @@ async function qualitySource(spec, lock) {
     }
     if (role) roles.add(role);
     const source = currentEntryOutputPath(entry, spec, index);
-    if (!existsSync6(source)) return { items: null, reason: `raw provider output is missing: ${source}` };
+    if (!existsSync7(source)) return { items: null, reason: `raw provider output is missing: ${source}` };
     if (await sha256File(source) !== output.sha256) {
       return { items: null, reason: "raw provider output was modified after download" };
     }
@@ -5733,7 +5757,7 @@ async function inspectQualityProfile(spec, lock) {
   }
   const sourcePaths = source.items.map((item) => item.path);
   const expectedOutputs = spec.generator === "frames" ? source.items.map((item, index) => qualityFrameOutputPath(output, item.role, index)) : [output];
-  if (!existsSync6(record)) {
+  if (!existsSync7(record)) {
     return {
       key,
       state: "needs-refinement",
@@ -5914,7 +5938,7 @@ async function requireApprovedQualitySources(specs, lock, assetIds, outputRoles)
 }
 
 // src/pipeline/revision.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import path12 from "path";
 async function inspectRevisionReadiness(spec, lock) {
   if (!spec.revision) return null;
@@ -5930,14 +5954,14 @@ async function inspectRevision(spec, lock, seen) {
       reason: `revision source ${spec.styleId}/${revision.sourceAssetId} is not ready: ${dependency.reason}`
     };
   }
-  if (!revision.sourceSha256 || !existsSync7(revision.sourceFile)) {
+  if (!revision.sourceSha256 || !existsSync8(revision.sourceFile)) {
     return { ready: false, reason: `revision source is missing: ${revision.sourceFile}` };
   }
   if (await sha256File(revision.sourceFile) !== revision.sourceSha256) {
     return { ready: false, reason: "revision source changed after the manifest was resolved" };
   }
   if (revision.maskFile) {
-    if (!revision.maskSha256 || !existsSync7(revision.maskFile)) {
+    if (!revision.maskSha256 || !existsSync8(revision.maskFile)) {
       return { ready: false, reason: `revision mask is missing: ${revision.maskFile}` };
     }
     if (await sha256File(revision.maskFile) !== revision.maskSha256) {
@@ -5968,7 +5992,7 @@ async function inspectParent(spec, lock, seen) {
   }
   if (spec.source) {
     const source = path12.resolve(spec.root, spec.source);
-    return existsSync7(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
+    return existsSync8(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[key];
   if (!entry) return { ready: false, reason: "parent is not in the lockfile" };
@@ -5982,7 +6006,7 @@ async function inspectParent(spec, lock, seen) {
   for (let index = 0; index < entry.outputs.length; index++) {
     const output = entry.outputs[index];
     const file = currentEntryOutputPath(entry, spec, index);
-    if (!existsSync7(file)) return { ready: false, reason: `parent output is missing: ${file}` };
+    if (!existsSync8(file)) return { ready: false, reason: `parent output is missing: ${file}` };
     if (await sha256File(file) !== output.sha256) {
       return { ready: false, reason: `parent output was modified: ${file}` };
     }
@@ -6036,8 +6060,8 @@ async function buildPlan(specs, lock, opts = {}) {
     } else if (opts.force) {
       state = "missing";
       reason = "--force";
-    } else if (!entry && spec.source) {
-      if (existsSync8(path13.resolve(spec.root, spec.source))) {
+    } else if (!entry && spec.source && spec.generator !== "frames") {
+      if (existsSync9(path13.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -6045,7 +6069,7 @@ async function buildPlan(specs, lock, opts = {}) {
         reason = `declared source is missing: ${spec.source}`;
       }
     } else if (!entry) {
-      if (existsSync8(spec.outFile)) {
+      if (existsSync9(spec.outFile)) {
         state = "untracked";
         reason = "file on disk, no provenance recorded";
       } else {
@@ -6077,9 +6101,9 @@ async function buildPlan(specs, lock, opts = {}) {
     } else if (entry.status !== "downloaded") {
       state = "in-flight";
       reason = `awaiting ${entry.status}`;
-    } else if (entry.outputs.length === 0 || entry.outputs.some((_output, index) => !existsSync8(currentEntryOutputPath(entry, spec, index)))) {
+    } else if (entry.outputs.length === 0 || entry.outputs.some((_output, index) => !existsSync9(currentEntryOutputPath(entry, spec, index)))) {
       state = "orphaned";
-      reason = entry.outputs.length === 0 ? "no recorded output files" : `missing on disk: ${entry.outputs.filter((_output, index) => !existsSync8(currentEntryOutputPath(entry, spec, index))).map((o) => o.role ?? "asset").join(", ")}`;
+      reason = entry.outputs.length === 0 ? "no recorded output files" : `missing on disk: ${entry.outputs.filter((_output, index) => !existsSync9(currentEntryOutputPath(entry, spec, index))).map((o) => o.role ?? "asset").join(", ")}`;
     } else if (await anyOutputModified(entry, spec)) {
       state = "orphaned";
       reason = "output modified since download";
@@ -6407,7 +6431,7 @@ async function poll(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/fetch.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir3, readFile as readFile7, rename as rename3, rm as rm4, writeFile as writeFile3 } from "fs/promises";
 import path14 from "path";
 
@@ -6463,7 +6487,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
     if (opts.refresh) return e.outputs.length > 0 && Boolean(e.sourceUrls?.length || e.sourceUrl);
     if (!opts.repair) return false;
     const spec = specByKey.get(key);
-    return e.outputs.length === 0 || !spec || e.outputs.some((output) => !existsSync9(resolveOutputPath(output.path, spec.root)));
+    return e.outputs.length === 0 || !spec || e.outputs.some((output) => !existsSync10(resolveOutputPath(output.path, spec.root)));
   });
   const concurrency = Math.min(Math.max(1, opts.concurrency ?? 8), Math.max(1, pending.length));
   let cursor = 0;
@@ -6511,7 +6535,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
               continue;
             }
           }
-          if (existsSync9(target)) {
+          if (existsSync10(target)) {
             const currentHash = await sha256File(target);
             if (recorded && currentHash === recorded.sha256) {
               if (!fresh) {
@@ -6622,7 +6646,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
   const file = path14.join(cacheDir, cacheFileName(hash, mediaType));
-  if (!existsSync9(file)) return null;
+  if (!existsSync10(file)) return null;
   try {
     const buf = await readFile7(file);
     if (sha256(buf) !== hash) return null;
@@ -6643,7 +6667,7 @@ async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   try {
     await rename3(tmp, file);
   } catch (err) {
-    if (!existsSync9(file)) throw err;
+    if (!existsSync10(file)) throw err;
   } finally {
     await rm4(tmp, { force: true });
   }
@@ -6676,7 +6700,7 @@ async function pushTags(provider, specs, lock, opts = {}) {
 }
 
 // src/pipeline/doctor.ts
-import { constants, existsSync as existsSync10 } from "fs";
+import { constants, existsSync as existsSync11 } from "fs";
 import { access, stat as stat2 } from "fs/promises";
 import path15 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
@@ -6748,7 +6772,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
-      if (existsSync10(cached) && await sha256File(cached) === output.sha256) {
+      if (existsSync11(cached) && await sha256File(cached) === output.sha256) {
         hasCache = true;
         break;
       }
@@ -6851,13 +6875,13 @@ async function nearestExistingDirectory(start) {
 }
 
 // src/pipeline/adopt.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
 import path16 from "path";
 
 // src/cache.ts
 import { mkdir as mkdir4, readFile as readFile8, rename as rename4, rm as rm5, writeFile as writeFile4 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import pathModule from "path";
 import { z as z3 } from "zod";
 var HashCacheSchema = z3.object({
@@ -6873,7 +6897,7 @@ function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
 async function loadCache(path31) {
-  if (!existsSync11(path31)) return { version: 1, hashes: {} };
+  if (!existsSync12(path31)) return { version: 1, hashes: {} };
   try {
     const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path31, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
@@ -6929,7 +6953,7 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const localByHash = /* @__PURE__ */ new Map();
   const unmatchedLocal = [];
   for (const spec of specs) {
-    if (!existsSync12(spec.outFile)) {
+    if (!existsSync13(spec.outFile)) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
@@ -7086,12 +7110,12 @@ function formatUnmatchedRemote(objects, limit = 15) {
 }
 
 // src/pick/server.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { readFile as readFile12 } from "fs/promises";
 
 // src/pipeline/init.ts
 import { readdir, readFile as readFile10, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import path17 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
@@ -7184,7 +7208,7 @@ function mode(values) {
   return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 64;
 }
 async function writeManifestFile(target, manifest) {
-  if (existsSync13(target)) {
+  if (existsSync14(target)) {
     throw new Error(`${target} already exists \u2014 refusing to overwrite an existing manifest.`);
   }
   await writeFile6(target, JSON.stringify(manifest, null, 2) + "\n");
@@ -7670,7 +7694,7 @@ async function currentArt(entry, spec) {
   const previous = primaryOutput({ ...entry, outputs: entry.supersededOutputs });
   if (!previous) return null;
   const file = resolveOutputPath(previous.path, spec.root);
-  if (!existsSync14(file)) return null;
+  if (!existsSync15(file)) return null;
   const contentType = previous.mediaType ?? mediaTypeFromExtension(file);
   if (!contentType) return null;
   let width = entry.width;
@@ -7841,13 +7865,13 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { readFile as readFile16, stat as stat3 } from "fs/promises";
 import path22 from "path";
 
 // src/workspace.ts
 import { mkdir as mkdir5, readFile as readFile13, rename as rename5, rm as rm6, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import path18 from "path";
 import { z as z4 } from "zod";
 var WorkspaceProjectSchema = z4.object({
@@ -7873,7 +7897,7 @@ ${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message
   );
 }
 async function loadWorkspace(workspacePath) {
-  if (!existsSync15(workspacePath)) return { version: 1, projects: [] };
+  if (!existsSync16(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
     raw = JSON.parse(await readFile13(workspacePath, "utf8"));
@@ -7925,14 +7949,14 @@ function validateWorkspace(ws, dir) {
         message: `project "${project.id}" stores an absolute path \u2014 the catalog will not resolve correctly if this tree is cloned or moved elsewhere`
       });
     }
-    if (!existsSync15(manifestPath)) {
+    if (!existsSync16(manifestPath)) {
       diagnostics.push({
         id: "missing-manifest",
         level: "error",
         message: `project "${project.id}" manifest not found: ${manifestPath}`
       });
     }
-    if (!existsSync15(lockPath)) {
+    if (!existsSync16(lockPath)) {
       diagnostics.push({
         id: "missing-lock",
         level: "error",
@@ -8233,7 +8257,7 @@ async function applyManifestEdit(manifestPath, edit) {
 
 // src/pipeline/hand-edit.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { copyFile, mkdir as mkdir6, readFile as readFile15, rename as rename7, rm as rm8, writeFile as writeFile9 } from "fs/promises";
 import path20 from "path";
 import { z as z6 } from "zod";
@@ -8246,36 +8270,59 @@ function handEditPath(loaded, spec) {
   const file = inside ? relative : path20.basename(spec.outFile);
   return path20.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
 }
-function handEditBase(spec, lock) {
+function handEditBases(spec, lock) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
   if (entry) {
-    if (entry.outputs.length !== 1) return null;
-    const primary = primaryOutput(entry);
-    if (!primary || primary.mediaType && primary.mediaType !== "image/png") return null;
-    const file = currentEntryOutputPath(entry, spec, 0);
-    return existsSync16(file) ? file : null;
+    if (entry.outputs.length !== 1 && !isMemberSetEntry(entry)) return null;
+    const members = entry.outputs.map((output, index) => ({
+      role: entry.outputs.length === 1 ? null : output.role ?? null,
+      path: currentEntryOutputPath(entry, spec, index),
+      mediaType: output.mediaType
+    }));
+    if (members.some((member) => member.mediaType && member.mediaType !== "image/png")) return null;
+    if (entry.outputs.length === 1 && !primaryOutput(entry)) return null;
+    if (!members.every((member) => existsSync17(member.path))) return null;
+    return members.map(({ role, path: file }) => ({ role, path: file }));
+  }
+  return existsSync17(spec.outFile) ? [{ role: null, path: spec.outFile }] : null;
+}
+function handEditMembers(loaded, spec, lock, editPath) {
+  const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
+  const bases = handEditBases(spec, lock);
+  if (entry && isMemberSetEntry(entry)) {
+    return entry.outputs.map((output, index) => ({
+      role: output.role ?? null,
+      path: memberPath(editPath, output.role, index, entry.outputs.length, output.mediaType),
+      base: bases?.[index]?.path ?? null
+    }));
   }
-  return existsSync16(spec.outFile) ? spec.outFile : null;
+  return [{ role: null, path: editPath, base: bases?.[0]?.path ?? null }];
 }
 async function startHandEdit(loaded, lock, spec, opts = {}) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
-  if (entry && entry.outputs.length > 1) {
+  if (entry && entry.outputs.length > 1 && !isMemberSetEntry(entry)) {
+    throw new ManifestEditError(
+      `${spec.styleId}/${spec.assetId} is a set of ${entry.outputs.length} outputs that are not all PNG; hand edits cover PNG images and sets of them`
+    );
+  }
+  if (entry && spec.source && isMemberSetEntry(entry) && !sourceIsStem(spec.source, entry, loaded.root)) {
     throw new ManifestEditError(
-      `${spec.styleId}/${spec.assetId} has ${entry.outputs.length} outputs; hand edits currently cover single-image assets`
+      `${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 ? path20.resolve(loaded.root, spec.source) : null;
   const editPath = existing ?? handEditPath(loaded, spec);
+  const members = handEditMembers(loaded, spec, lock, editPath);
   let created = false;
-  if (!existsSync16(editPath)) {
-    const base = handEditBase(spec, lock);
-    if (!base) {
+  for (const member of members) {
+    if (existsSync17(member.path)) continue;
+    if (!member.base) {
       throw new ManifestEditError(
         `${spec.styleId}/${spec.assetId} has no generated PNG on disk to start from; generate or restore it first`
       );
     }
-    await mkdir6(path20.dirname(editPath), { recursive: true });
-    await copyFile(base, editPath);
+    await mkdir6(path20.dirname(member.path), { recursive: true });
+    await copyFile(member.base, member.path);
     created = true;
   }
   const source = portableOutputPath(editPath, loaded.root);
@@ -8292,7 +8339,7 @@ async function startHandEdit(loaded, lock, spec, opts = {}) {
     declared = result.changed;
     manifestSha256 = result.sha256;
   }
-  return { editPath, source, created, declared, manifestSha256 };
+  return { editPath, members, source, created, declared, manifestSha256 };
 }
 async function detachHandEdit(loaded, spec, opts = {}) {
   if (!spec.source) {
@@ -8306,19 +8353,44 @@ async function detachHandEdit(loaded, spec, opts = {}) {
   });
   return { manifestSha256: result.sha256, changed: result.changed };
 }
-var HandEditCompanionSchema = z6.object({
-  version: z6.literal(1),
-  /** sha256 of the generated art the edit started from; null when it started from untracked art. */
+var CompanionOutputSchema = z6.object({
+  /** Output role for a set member; null for a single image. */
+  role: z6.string().nullable(),
+  /** sha256 of the generated file this member started from; null when it started from untracked art. */
   basedOn: z6.string().regex(/^[0-9a-f]{64}$/).nullable(),
-  /** sha256 of the edit PNG as saved, so a later change by another tool is visible. */
-  sha256: z6.string().regex(/^[0-9a-f]{64}$/),
+  /** sha256 of the member as saved, so a later change by another tool is visible. */
+  sha256: z6.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
+var CompanionV2Schema = z6.object({
+  version: z6.literal(2),
   /** Editor identity the bridge reported, e.g. `pixelorama@v1.2.2-stable`. */
   editor: z6.string().min(1),
   protocol: z6.number().int().positive(),
   savedAt: z6.string().datetime(),
   /** Basename of the layered project file beside the edit, when one was kept. */
+  project: z6.string().min(1).nullable(),
+  /** One entry per file, in output order. */
+  outputs: z6.array(CompanionOutputSchema).min(1)
+}).strict();
+var CompanionV1Schema = z6.object({
+  version: z6.literal(1),
+  basedOn: z6.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  sha256: z6.string().regex(/^[0-9a-f]{64}$/),
+  editor: z6.string().min(1),
+  protocol: z6.number().int().positive(),
+  savedAt: z6.string().datetime(),
   project: z6.string().min(1).nullable()
 }).strict();
+var HandEditCompanionSchema = z6.union([CompanionV2Schema, CompanionV1Schema]).transform(
+  (value) => value.version === 2 ? value : {
+    version: 2,
+    editor: value.editor,
+    protocol: value.protocol,
+    savedAt: value.savedAt,
+    project: value.project,
+    outputs: [{ role: null, basedOn: value.basedOn, sha256: value.sha256 }]
+  }
+);
 function handEditCompanionPath(editPath) {
   return editPath.replace(/\.png$/i, "") + ".edit.json";
 }
@@ -8340,45 +8412,79 @@ async function readHandEditCompanion(editPath) {
 }
 var MAX_HAND_EDIT_BYTES = 16 * 1024 * 1024;
 async function saveHandEdit(loaded, lock, spec, input) {
-  if (input.png.length > MAX_HAND_EDIT_BYTES) {
-    throw new ManifestEditError(`the edit is ${input.png.length} bytes; the limit is ${MAX_HAND_EDIT_BYTES}`);
-  }
+  const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
+  const memberSet = entry ? isMemberSetEntry(entry) : false;
+  const incoming = input.frames ?? (input.png ? [{ role: null, png: input.png }] : []);
+  if (!incoming.length) throw new ManifestEditError("the save carried no image");
   if (input.project && input.project.length > MAX_HAND_EDIT_BYTES) {
     throw new ManifestEditError(`the project file is ${input.project.length} bytes; the limit is ${MAX_HAND_EDIT_BYTES}`);
   }
-  let decoded;
-  try {
-    validateMedia(input.png, MediaType.PNG);
-    decoded = decodePng(input.png);
-  } catch (error) {
-    throw new ManifestEditError(`the edit is not a valid PNG: ${error instanceof Error ? error.message : String(error)}`);
+  if (memberSet) {
+    const expected = entry.outputs.map((output) => output.role ?? null);
+    const got = incoming.map((frame) => frame.role);
+    if (got.length !== expected.length || expected.some((role, index) => got[index] !== role)) {
+      throw new ManifestEditError(
+        `${spec.styleId}/${spec.assetId} is a set of ${expected.length} members (${expected.join(", ")}); the editor returned ${got.length} (${got.map((role) => role ?? "new").join(", ")}) \u2014 keep the frames it opened with`
+      );
+    }
+  } else if (incoming.length !== 1) {
+    throw new ManifestEditError(`${spec.styleId}/${spec.assetId} is one image; the editor returned ${incoming.length} frames \u2014 keep a single frame`);
   }
-  const base = handEditBase(spec, lock);
-  const expected = base ? decodePng(await readFile15(base)) : { width: spec.width, height: spec.height };
-  if (decoded.width !== expected.width || decoded.height !== expected.height) {
-    throw new ManifestEditError(
-      `the edit is ${decoded.width}\xD7${decoded.height}; ${spec.styleId}/${spec.assetId} is ${expected.width}\xD7${expected.height}`
-    );
+  const decoded = incoming.map((frame, index) => {
+    if (frame.png.length > MAX_HAND_EDIT_BYTES) {
+      throw new ManifestEditError(`the edit is ${frame.png.length} bytes; the limit is ${MAX_HAND_EDIT_BYTES}`);
+    }
+    try {
+      validateMedia(frame.png, MediaType.PNG);
+      return decodePng(frame.png);
+    } catch (error) {
+      const which = memberSet ? `member ${frame.role ?? index}` : "the edit";
+      throw new ManifestEditError(`${which} is not a valid PNG: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+  const bases = handEditBases(spec, lock);
+  const expectedSize = bases?.[0] ? decodePng(await readFile15(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";
+      throw new ManifestEditError(
+        `${which} is ${image.width}\xD7${image.height}; ${spec.styleId}/${spec.assetId} is ${expectedSize.width}\xD7${expectedSize.height}`
+      );
+    }
   }
   const started = await startHandEdit(loaded, lock, spec, { expectedSha256: input.expectedSha256 });
-  const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
-  const basedOn = entry ? primaryOutput(entry)?.sha256 ?? null : null;
-  const digest2 = sha256(input.png);
   const projectPath = input.project ? handEditProjectPath(started.editPath) : null;
   const companion = {
-    version: 1,
-    basedOn,
-    sha256: digest2,
+    version: 2,
     editor: input.editor,
     protocol: input.protocol,
     savedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
-    project: projectPath ? path20.basename(projectPath) : null
+    project: projectPath ? path20.basename(projectPath) : null,
+    outputs: incoming.map((frame, index) => ({
+      role: frame.role,
+      basedOn: basedOnHash(entry, index),
+      sha256: sha256(frame.png)
+    }))
   };
-  await replaceFile(started.editPath, input.png);
+  for (const [index, member] of started.members.entries()) {
+    await replaceFile(member.path, incoming[index].png);
+  }
   if (projectPath && input.project) await replaceFile(projectPath, input.project);
   const companionPath = handEditCompanionPath(started.editPath);
   await replaceFile(companionPath, JSON.stringify(companion, null, 2) + "\n");
-  return { ...started, sha256: digest2, basedOn, companionPath, projectPath };
+  return {
+    ...started,
+    sha256: companion.outputs[0].sha256,
+    basedOn: companion.outputs[0].basedOn,
+    companion,
+    companionPath,
+    projectPath
+  };
+}
+function basedOnHash(entry, index) {
+  if (!entry) return null;
+  if (entry.outputs.length === 1) return primaryOutput(entry)?.sha256 ?? null;
+  return entry.outputs[index]?.sha256 ?? null;
 }
 async function replaceFile(file, bytes) {
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
@@ -8425,7 +8531,10 @@ var HandEditRequestSchema = z7.discriminatedUnion("action", [
     assetId: z7.string().min(1),
     styleId: z7.string().min(1),
     expectedSha256: z7.string().regex(/^[0-9a-f]{64}$/),
-    png: Base64.min(1),
+    /** The flattened image; for a frame set, `frames` instead. */
+    png: Base64.min(1).optional(),
+    /** Every frame of a set, tagged with the role it was opened under (null for one added in the editor). */
+    frames: z7.array(z7.object({ role: z7.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
     /** The editor's layered project file, kept beside the edit. */
     pxo: Base64.optional(),
     /** Editor identity from the bridge's ready message. */
@@ -8448,18 +8557,23 @@ function createGalleryEditHandler(opts) {
         const started = await startHandEdit(ctx.loaded, ctx.lock, spec, { expectedSha256: request.expectedSha256 });
         log2(`  hand edit ${started.created ? "created" : "found"}: ${started.source}${started.declared ? " (declared in the manifest)" : ""}`);
         if (request.open) {
-          const command = (opts.openEditor ?? openInEditor)(started.editPath);
+          const command = (opts.openEditor ?? openInEditor)(started.members[0].path);
           log2(`  opened with: ${command}`);
         }
       } else if (request.action === "save-edit") {
+        if (request.png !== void 0 === (request.frames !== void 0)) {
+          throw new ManifestEditError("invalid edit: send png for one image or frames for a set, not both");
+        }
         const saved = await saveHandEdit(ctx.loaded, ctx.lock, spec, {
-          png: Buffer.from(request.png, "base64"),
+          ...request.png !== void 0 ? { png: Buffer.from(request.png, "base64") } : {},
+          ...request.frames ? { frames: request.frames.map((frame) => ({ role: frame.role, png: Buffer.from(frame.png, "base64") })) } : {},
           ...request.pxo ? { project: Buffer.from(request.pxo, "base64") } : {},
           editor: request.editor,
           protocol: request.protocol,
           expectedSha256: request.expectedSha256
         });
-        log2(`  hand edit saved from ${request.editor}: ${saved.source}${saved.declared ? " (declared in the manifest)" : ""}${saved.projectPath ? " + project file" : ""}`);
+        const what = saved.members.length > 1 ? `${saved.source} (${saved.members.length} frames)` : saved.source;
+        log2(`  hand edit saved from ${request.editor}: ${what}${saved.declared ? " (declared in the manifest)" : ""}${saved.projectPath ? " + project file" : ""}`);
       } else {
         const result2 = await detachHandEdit(ctx.loaded, spec, { expectedSha256: request.expectedSha256 });
         if (result2.changed) log2(`  hand edit detached: ${request.styleId}/${request.assetId} (file kept)`);
@@ -8507,6 +8621,18 @@ function matchesFilter(filter, styleId, assetId) {
   if (filter?.assets?.length && !filter.assets.includes(assetId)) return false;
   return true;
 }
+var MAX_COMPARED_BYTES = 8 * 1024 * 1024;
+async function samePixels(a, b) {
+  try {
+    const [left, right] = await Promise.all([readFile16(a), readFile16(b)]);
+    if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
+    const x = decodePng(left);
+    const y = decodePng(right);
+    return x.width === y.width && x.height === y.height && x.pixels.equals(y.pixels);
+  } catch {
+    return false;
+  }
+}
 function metadataFps(entry) {
   if (!entry) return null;
   const namespace = entry.providerMetadata?.[entry.provider];
@@ -8554,7 +8680,7 @@ async function describeQuality(media, root, inspection) {
     outputPaths.map((file) => describeOutput(media, root, path22.resolve(root, file)))
   );
   const recordPath = path22.resolve(root, inspection.record);
-  const recordExists = existsSync17(recordPath);
+  const recordExists = existsSync18(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -8624,6 +8750,8 @@ async function buildGallerySnapshot(opts) {
     const asset = loaded.manifest.assets[spec.assetId] ?? null;
     let outputs;
     let edit = null;
+    let edits = [];
+    let editChanged = [];
     let editStatus = null;
     let editMeta = null;
     if (entry && entry.outputs.length) {
@@ -8634,13 +8762,19 @@ async function buildGallerySnapshot(opts) {
       );
       if (spec.source) {
         const editPath = path22.resolve(root, spec.source);
-        const editSha = existsSync17(editPath) ? await sha256File(editPath) : null;
-        edit = await describeOutput(media, root, editPath, { sha256: editSha });
-        const generated = outputs[0];
+        const memberCount = sourceIsStem(spec.source, entry, root) ? entry.outputs.length : 1;
+        const editShas = await Promise.all(
+          Array.from({ length: memberCount }, async (_, index) => {
+            const file = sourceOutputPath(spec.source, entry, index, root);
+            return { file, sha256: existsSync18(file) ? await sha256File(file) : null };
+          })
+        );
+        edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
+        edit = edits[0] ?? null;
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && existsSync17(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && existsSync18(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -8650,18 +8784,34 @@ async function buildGallerySnapshot(opts) {
           editMeta = {
             editor: companion.editor,
             savedAt: companion.savedAt,
-            basedOn: companion.basedOn,
-            changedSince: editSha !== null && editSha !== companion.sha256,
+            basedOn: companion.outputs[0]?.basedOn ?? null,
+            changedSince: editShas.some(({ sha256: editSha }, index) => {
+              const recorded = companion.outputs[index]?.sha256;
+              return editSha !== null && recorded !== void 0 && editSha !== recorded;
+            }),
             project: project ? portableOutputPath(projectPath, root) : null,
             projectUrl
           };
         }
-        const regenerated = companion ? generated?.sha256 !== void 0 && generated.sha256 !== null && companion.basedOn !== generated.sha256 : Boolean(generated?.modifiedAt && edit.modifiedAt && generated.modifiedAt > edit.modifiedAt && generated.exists);
-        editStatus = !edit.exists ? "missing" : generated && editSha === generated.sha256 ? "same" : regenerated ? "regenerated-since" : "edited";
+        const regenerated = edits.some((member, index) => {
+          const generated = outputs[index];
+          if (companion) {
+            const recorded = companion.outputs[index];
+            return recorded !== void 0 && generated.sha256 !== null && recorded.basedOn !== generated.sha256;
+          }
+          return Boolean(generated.modifiedAt && member.modifiedAt && generated.modifiedAt > member.modifiedAt && generated.exists);
+        });
+        editChanged = await Promise.all(edits.map(async (member, index) => {
+          const generated = outputs[index];
+          if (!member.exists || !generated.exists) return true;
+          if (member.sha256 === generated.sha256) return false;
+          return !await samePixels(member.absolutePath, generated.absolutePath);
+        }));
+        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, path22.resolve(root, spec.source))];
-    } else if (!entry && existsSync17(spec.outFile)) {
+    } else if (!entry && existsSync18(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -8706,6 +8856,8 @@ async function buildGallerySnapshot(opts) {
       asset,
       source: spec.source ?? null,
       edit,
+      edits,
+      editChanged,
       editStatus,
       editMeta,
       upstreamUrl: entry?.provider === "pixellab" ? pixelLabObjectUrl(entry.generator, entry.objectId) : null,
@@ -8763,6 +8915,8 @@ async function buildGallerySnapshot(opts) {
       asset: null,
       source: null,
       edit: null,
+      edits: [],
+      editChanged: [],
       editStatus: null,
       editMeta: null,
       upstreamUrl: entry.provider === "pixellab" ? pixelLabObjectUrl(entry.generator, entry.objectId) : null,
@@ -9697,10 +9851,15 @@ window.addEventListener('message', (e) => {
 // declares the file the same way pixelkiln edit does.
 
 let SHEET = null;
-const editorSource = (item) => item.edit && item.edit.exists ? item.edit
-  : item.outputs.length === 1 && item.outputs[0].exists && item.outputs[0].mediaType === 'image/png' ? item.outputs[0] : null;
-const canEditInBrowser = (item) => EDITOR && EDITABLE && item.declared && item.asset && projectOf(item)?.manifestSha256 && editorSource(item) &&
-  !(item.outputs.length > 1);
+// What the editor gets: the edit files when they are all there, else the
+// generated outputs (one PNG, or every frame of a set).
+const editorSources = (item) => {
+  if (item.edits.length && item.edits.every((e) => e.exists)) return { files: item.edits, fromEdit: true };
+  if (editableOutputs(item)) return { files: item.outputs, fromEdit: false };
+  return null;
+};
+const editorSource = (item) => { const s = editorSources(item); return s ? s.files[0] : null; };
+const canEditInBrowser = (item) => EDITOR && EDITABLE && item.declared && item.asset && projectOf(item)?.manifestSha256 && editorSources(item);
 const toBase64 = (buf) => new Promise((resolve, reject) => {
   const r = new FileReader();
   r.onload = () => resolve(String(r.result).slice(String(r.result).indexOf(',') + 1));
@@ -9729,7 +9888,7 @@ function openEditorSheet(item) {
   const bar = el('div', 'rbar');
   const close = el('button', null, 'Close'); close.type = 'button';
   close.onclick = () => closeEditorSheet();
-  const title = el('b', null, (item.project ? item.project + ':' : '') + item.styleId + '/' + item.assetId + ' \xB7 ' + item.width + '\xD7' + item.height);
+  const title = el('b', null, (item.project ? item.project + ':' : '') + item.styleId + '/' + item.assetId + ' \xB7 ' + item.width + '\xD7' + item.height + (item.outputs.length > 1 ? ' \xB7 ' + item.outputs.length + ' ' + memberNoun(item, item.outputs.length) : ''));
   const status = el('span', 'st');
   const acts = el('div', 'acts');
   const msg = el('span', 'msg');
@@ -9750,23 +9909,34 @@ function openEditorSheet(item) {
   stage.append(frame, loading);
   panel.append(bar, stage);
   host.append(scrim, panel);
-  SHEET = { item, frame, loading, status, msg, save, saveClose, dirty: false, opened: false, ready: null, pending: null, requests: 0, source: src, sentProject: false };
+  SHEET = { item, frame, loading, status, msg, save, saveClose, dirty: false, opened: false, ready: null, pending: null, requests: 0, source: src, sentProject: false, roles: null };
   sheetStatus('cool', 'loading');
   sheetButtons();
   close.focus({ preventScroll: true });
 }
-// The edit file is what the editor gets; when a browser save kept the layered
-// project beside it, that goes along too and the editor restores the layers,
-// falling back to the flattened PNG if the file cannot be read.
+// The edit files are what the editor gets; when a browser save kept the
+// layered project beside them, that goes along too and the editor restores
+// the layers, falling back to the flattened PNGs if the file cannot be read.
+// A frame set is sent as frames, one per member, and comes back the same way.
 async function sendOpen() {
-  const { item, source } = SHEET;
+  const { item } = SHEET;
+  const sources = editorSources(item);
   const style = snap.styles.find((s) => s.id === item.styleId && s.project === item.project);
-  const projectUrl = source === item.edit && item.editMeta && item.editMeta.projectUrl && SHEET.ready.version >= 2 ? item.editMeta.projectUrl : null;
-  let png, pxo = null;
+  const projectUrl = sources.fromEdit && item.editMeta && item.editMeta.projectUrl && SHEET.ready.version >= 2 ? item.editMeta.projectUrl : null;
+  const set = sources.files.length > 1;
+  if (set && SHEET.ready.version < 3) {
+    SHEET.msg.textContent = 'This editor build cannot open sets; reinstall it with pixelkiln tools install editor.';
+    sheetStatus('bad', 'unsupported');
+    return;
+  }
+  const pngs = [];
+  let pxo = null;
   try {
-    const res = await fetch(source.url, { cache: 'no-store' });
-    if (!res.ok) throw new Error(await res.text());
-    png = await res.arrayBuffer();
+    for (const file of sources.files) {
+      const res = await fetch(file.url, { cache: 'no-store' });
+      if (!res.ok) throw new Error(await res.text());
+      pngs.push(await res.arrayBuffer());
+    }
     if (projectUrl) {
       const p = await fetch(projectUrl, { cache: 'no-store' });
       if (p.ok) pxo = await p.arrayBuffer();
@@ -9778,12 +9948,22 @@ async function sendOpen() {
   if (!SHEET) return;
   const request = 'open-' + (++SHEET.requests);
   SHEET.sentProject = !!pxo;
+  SHEET.roles = set ? item.outputs.map((o) => o.role || null) : null;
   const message = {
     type: 'pixelkiln:open', request,
     asset: { key: item.styleId + '/' + item.assetId, id: item.id, name: item.assetId, width: item.width, height: item.height },
-    png, palette: style ? style.palette : [],
+    png: pngs[0], palette: style ? style.palette : [],
   };
-  const transfer = [png];
+  const transfer = [pngs[0]];
+  if (set) {
+    message.frames = pngs.map((png, i) => ({ role: SHEET.roles[i], png }));
+    // A tile set is not an animation; a slow rate keeps its timeline still-ish.
+    message.fps = isFrameSet(item) ? (item.fps || 12) : 1;
+    for (const png of pngs.slice(1)) transfer.push(png);
+    // The first frame is both png (older editors) and frames[0]; copy it so both transfer.
+    message.png = pngs[0].slice(0);
+    transfer.push(message.png);
+  }
   if (pxo) { message.pxo = pxo; transfer.push(pxo); }
   SHEET.frame.contentWindow.postMessage(message, location.origin, transfer);
   sheetStatus('cool', 'opening');
@@ -9811,8 +9991,9 @@ async function onEditorMessage(m) {
     case 'pixelkiln:opened':
       SHEET.opened = true;
       SHEET.loading.remove();
-      if (m.source === 'pxo') sheetStatus('ok', 'editing the edit file with its ' + (m.layers === 1 ? 'layer' : m.layers + ' layers') + ' restored');
-      else if (SHEET.sentProject) sheetStatus('warn', 'editing the flattened edit file; its layer file could not be opened');
+      if (m.source === 'pxo') sheetStatus('ok', 'editing the edit file' + (m.frames > 1 ? 's' : '') + ' with ' + (m.layers === 1 ? 'the layer' : m.layers + ' layers') + (m.frames > 1 ? ' and ' + m.frames + ' ' + memberNoun(SHEET.item, m.frames) : '') + ' restored');
+      else if (SHEET.sentProject) sheetStatus('warn', 'editing the flattened edit file' + (m.frames > 1 ? 's' : '') + '; the layer file could not be opened');
+      else if (m.source === 'frames') sheetStatus('ok', (SHEET.item.edits.length ? 'editing the edit files' : 'editing a copy of the generated ' + memberNoun(SHEET.item, m.frames)) + ' as ' + m.frames + ' frames' + (isFrameSet(SHEET.item) ? '' : ', one per ' + memberNoun(SHEET.item, 1)));
       else sheetStatus('ok', SHEET.item.edit && SHEET.item.edit.exists ? 'editing the edit file' : 'editing a copy of the generated art');
       sheetButtons();
       break;
@@ -9825,14 +10006,21 @@ async function onEditorMessage(m) {
       const pending = SHEET.pending;
       if (!pending || pending.request !== m.request) return;
       try {
-        const body = { png: await toBase64(m.png), editor: SHEET.ready.editor, protocol: SHEET.ready.version };
+        const body = { editor: SHEET.ready.editor, protocol: SHEET.ready.version };
+        if (SHEET.roles) {
+          if (!Array.isArray(m.frames)) throw new Error('the editor returned no frames');
+          body.frames = [];
+          for (const f of m.frames) body.frames.push({ role: f.role === undefined ? null : f.role, png: await toBase64(f.png) });
+        } else {
+          body.png = await toBase64(m.png);
+        }
         if (m.pxo && m.pxo.byteLength) body.pxo = await toBase64(m.pxo);
         await postHandEdit(SHEET.item, 'save-edit', body);
         const saved = snap.items.find((i) => i.id === SHEET.item.id);
         if (saved) SHEET.item = saved;
         SHEET.dirty = false;
         SHEET.pending = null;
-        ui.notice = { id: SHEET.item.id, text: 'Saved ' + (saved && saved.edit ? saved.edit.path : 'the edit') + '. mount and pack place it in place of the generated art.' };
+        ui.notice = { id: SHEET.item.id, text: 'Saved ' + (saved && saved.edits.length > 1 ? saved.edits.length + ' ' + memberNoun(saved, saved.edits.length) + ' to ' + saved.source : saved && saved.edit ? saved.edit.path : 'the edit') + '. mount and pack place ' + (saved && saved.edits.length > 1 ? 'them' : 'it') + ' in place of the generated art.' };
         render();
         if (pending.close) { closeEditorSheet(true); return; }
         sheetStatus('ok', 'saved');
@@ -9980,7 +10168,7 @@ function clearFilters() {
 function thumb(item) {
   const cell = el('div', 'cell');
   // A hand edit is what ships, so it is what the card shows.
-  const shown = item.edit && item.edit.url && item.editStatus === 'edited' ? [item.edit] : item.outputs.filter((o) => o.url);
+  const shown = item.edit && item.editStatus === 'edited' && item.edits.every((e) => e.url) ? item.edits : item.outputs.filter((o) => o.url);
   if (!shown.length) {
     cell.classList.add('none');
     cell.append(el('span', null, item.state === 'missing' ? 'not generated yet'
@@ -10394,7 +10582,7 @@ function openCompare() {
 // ---- hand edits -------------------------------------------------------------
 
 const EDIT_STATUS_TEXT = {
-  same: 'A copy of the generated art, not changed yet. Open it in your editor and save.',
+  same: 'The generated art\u2019s pixels, not changed yet. Open it in your editor and save.',
   edited: 'Differs from the generated art. mount and pack place this file; the generated file stays as the record.',
   'regenerated-since': 'The generated art changed after this edit was saved \u2014 the edit is based on an older generation.',
   missing: 'The declared file is not on disk.',
@@ -10405,12 +10593,18 @@ async function postHandEdit(item, action, extra) {
   if (item.project) body.project = item.project;
   snap = await postEdit(body);
 }
+// A single PNG or a set of them \u2014 frames, tiles \u2014 is hand-editable, one file
+// per member; a set with a GIF in it is not.
+const editableOutputs = (item) => item.outputs.length && item.outputs.every((o) => o.exists && o.mediaType === 'image/png');
+// What the members of a set are called: frames for an animation, tiles for a tile set.
+const memberNoun = (item, n) => isFrameSet(item) ? (n === 1 ? 'frame' : 'frames')
+  : item.outputs.every((o) => o.role && /^tile/i.test(o.role)) ? (n === 1 ? 'tile' : 'tiles') : (n === 1 ? 'member' : 'members');
 function handEditSection(item) {
-  const canStart = EDITABLE && item.declared && item.asset && projectOf(item)?.manifestSha256 &&
-    item.outputs.length === 1 && item.outputs[0].exists && item.outputs[0].mediaType === 'image/png';
+  const canStart = EDITABLE && item.declared && item.asset && projectOf(item)?.manifestSha256 && editableOutputs(item);
   if (!item.edit && !canStart) return null;
+  const set = item.edits.length > 1;
   const s = el('section', 'meta');
-  s.append(el('h3', null, 'Hand edit'));
+  s.append(el('h3', null, set ? 'Hand edit (' + item.edits.length + ' ' + memberNoun(item, item.edits.length) + ')' : 'Hand edit'));
   if (item.edit) {
     const pair = el('div', 'pair');
     const shared = displayScale(item.width, item.height, 200, 160);
@@ -10424,24 +10618,36 @@ function handEditSection(item) {
       f.append(el('figcaption', null, label));
       return f;
     };
-    pair.append(fig(item.outputs[0], 'generated'), fig(item.edit, 'edit'));
+    // For a set, the member the preview is on; the strip there steps through them.
+    const at = set ? Math.min(ui.member, item.edits.length - 1) : 0;
+    const which = set ? ' \xB7 ' + (item.outputs[at].role || memberNoun(item, 1) + ' ' + (at + 1)) : '';
+    pair.append(fig(item.outputs[at], 'generated' + which), fig(item.edits[at], 'edit' + which));
     s.append(pair);
     const dl = el('dl');
     const tone = item.editStatus === 'edited' ? 'ok' : item.editStatus === 'same' ? 'dim' : 'warn';
     const st = el('span', 'state-' + tone); st.append(el('i', 'dot ' + tone), document.createTextNode(' ' + item.editStatus));
     row(dl, 'status', st);
     row(dl, 'why', EDIT_STATUS_TEXT[item.editStatus] || '');
-    row(dl, 'file', item.edit.path, { mono: true, copy: item.edit.absolutePath });
-    if (item.edit.sha256) row(dl, 'sha256', item.edit.sha256.slice(0, 16) + '\u2026', { mono: true, copy: item.edit.sha256 });
-    row(dl, 'saved', fmtWhen(item.edit.modifiedAt));
+    if (set) {
+      row(dl, 'files', item.source + ' \u2014 one per ' + memberNoun(item, 1) + ': ' + item.edits.map((e) => e.path.split('/').pop()).join(', '), { mono: true, copy: item.edits.map((e) => e.absolutePath).join('\\n') });
+      const differing = item.editChanged.filter(Boolean).length;
+      row(dl, 'changed', differing + ' of ' + item.edits.length + ' ' + memberNoun(item, item.edits.length) + ' differ from the generated art' +
+        (differing ? ': ' + item.edits.filter((e, i) => item.editChanged[i]).map((e) => item.outputs[item.edits.indexOf(e)].role || e.path.split('/').pop()).join(', ') : ''));
+    } else {
+      row(dl, 'file', item.edit.path, { mono: true, copy: item.edit.absolutePath });
+      if (item.edit.sha256) row(dl, 'sha256', item.edit.sha256.slice(0, 16) + '\u2026', { mono: true, copy: item.edit.sha256 });
+    }
+    row(dl, 'saved', fmtWhen(item.edits.reduce((latest, e) => e.modifiedAt && (!latest || e.modifiedAt > latest) ? e.modifiedAt : latest, null)));
     if (item.editMeta) {
-      row(dl, 'editor', item.editMeta.editor + ', ' + fmtWhen(item.editMeta.savedAt) + (item.editMeta.changedSince ? ' \u2014 the file changed since' : ''));
-      if (item.editMeta.basedOn) row(dl, 'based on', item.editMeta.basedOn.slice(0, 16) + '\u2026', { mono: true, copy: item.editMeta.basedOn });
+      row(dl, 'editor', item.editMeta.editor + ', ' + fmtWhen(item.editMeta.savedAt) + (item.editMeta.changedSince ? ' \u2014 a file changed since' : ''));
+      if (item.editMeta.basedOn && !set) row(dl, 'based on', item.editMeta.basedOn.slice(0, 16) + '\u2026', { mono: true, copy: item.editMeta.basedOn });
       if (item.editMeta.project) row(dl, 'layers', item.editMeta.project, { mono: true });
     }
     s.append(dl);
   } else {
-    s.append(el('div', 'state-dim', 'Touch it up in your own editor. The generated file stays untouched; the edit is a sibling file the manifest points at, and mount and pack place that instead.'));
+    s.append(el('div', 'state-dim', item.outputs.length > 1
+      ? 'Touch the ' + memberNoun(item, 2) + ' up in your own editor or in the browser, where they open as ' + (isFrameSet(item) ? 'one animation' : 'the frames of one project') + '. The generated files stay untouched; the edit is one sibling file per ' + memberNoun(item, 1) + ' that the manifest points at, and mount, pack, and export place those instead.'
+      : 'Touch it up in your own editor. The generated file stays untouched; the edit is a sibling file the manifest points at, and mount and pack place that instead.'));
   }
   if (EDITABLE && item.declared && projectOf(item)?.manifestSha256) {
     const acts = el('div', 'hand-actions');
@@ -10469,10 +10675,11 @@ function handEditSection(item) {
     }
     if (item.edit) {
       go('Open in desktop editor', 'start-edit', { open: true }, 'Opened ' + item.edit.path + ' in your editor. Save there, then Refresh.');
-      go('Detach edit', 'detach-edit', {}, 'Detached. The file is still at ' + item.edit.path + '; the generated art is placed again.');
+      go('Detach edit', 'detach-edit', {}, 'Detached. The file' + (set ? 's are' : ' is') + ' still at ' + item.source + '; the generated art is placed again.');
     } else if (canStart) {
-      go('Edit by hand', 'start-edit', { open: true }, 'Created the edit file and opened it in your editor. Save there, then Refresh to see it here.');
-      go('Create edit file only', 'start-edit', { open: false }, 'Created the edit file and declared it in the manifest.');
+      const many = item.outputs.length > 1;
+      go('Edit by hand', 'start-edit', { open: true }, 'Created the edit file' + (many ? 's and opened the first ' + memberNoun(item, 1) : ' and opened it') + ' in your editor. Save there, then Refresh to see it here.');
+      go('Create edit file' + (many ? 's' : '') + ' only', 'start-edit', { open: false }, 'Created the edit file' + (many ? 's' : '') + ' and declared ' + (many ? 'them' : 'it') + ' in the manifest.');
     }
     acts.append(msg);
     s.append(acts);
@@ -11775,7 +11982,7 @@ import path24 from "path";
 
 // src/editor/install.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { mkdir as mkdir7, readFile as readFile18, rename as rename8, rm as rm9, stat as stat4, writeFile as writeFile10 } from "fs/promises";
 import os2 from "os";
 import path23 from "path";
@@ -11785,8 +11992,8 @@ var pin_default = {
   pixelorama: "v1.2.2",
   godot: "4.7.2",
   extensionsApi: 9,
-  protocol: 2,
-  release: "editor-pixelorama-v1.2.2-pk.10",
+  protocol: 3,
+  release: "editor-pixelorama-v1.2.2-pk.14",
   files: {
     "index.apple-touch-icon.png": {
       sha256: "ee5434873e0fed91e9a888c3ea5a8b79beac25999308be7a6eb41bf4ce640d27",
@@ -11801,7 +12008,7 @@ var pin_default = {
       bytes: 7298
     },
     "index.html": {
-      sha256: "ad777659ca39a22872437d44595b749c1637f83994d5f82d50dca861f2186b9c",
+      sha256: "2974146c89f4df9f796e840947c334aaf3e4fa3dd18bcd7e08db2eabfd0f086e",
       bytes: 5442
     },
     "index.icon.png": {
@@ -11813,8 +12020,8 @@ var pin_default = {
       bytes: 279815
     },
     "index.pck": {
-      sha256: "546a3f9851df0854c9f6052f29f1e559de79deb53b936d44a72c3475234c26ff",
-      bytes: 6427868
+      sha256: "736bd383c82fdadf31cc894caf08490b99c5df572aa20db683972c35c7a0465b",
+      bytes: 6429628
     },
     "index.png": {
       sha256: "6e3ca3eb4a99e4c07bdd89ebc873b440ec0ffd66ce1955160da9e7ed80d538d7",
@@ -11874,7 +12081,7 @@ async function editorStatus(opts = {}) {
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
     const file = path23.join(dir, name);
-    const info = existsSync18(file) ? await stat4(file).catch(() => null) : null;
+    const info = existsSync19(file) ? await stat4(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -12069,7 +12276,7 @@ function createGalleryEditorHandlers(opts = {}) {
 
 // src/pipeline/salvage.ts
 import { readFile as readFile20 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import path25 from "path";
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
@@ -12077,7 +12284,7 @@ function providerClaimId(provider, objectId) {
 async function loadClaims(lockPaths, opts = {}) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
-    if (!existsSync19(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!existsSync20(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
       parsed = parseLock(JSON.parse(await readFile20(p, "utf8")));
@@ -12138,7 +12345,7 @@ async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, cla
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
     if (path25.resolve(siblingManifestPath) === own) continue;
-    if (!existsSync19(siblingManifestPath)) continue;
+    if (!existsSync20(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
       siblings.push({ label: path25.basename(path25.dirname(siblingManifestPath)), manifest });
@@ -12360,11 +12567,11 @@ async function workspaceStatus(ws, dir) {
 }
 
 // src/pipeline/cache-health.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { readFile as readFile21, readdir as readdir2, rm as rm10 } from "fs/promises";
 import path26 from "path";
 async function inspectCaches(lock, lockPath, options = {}) {
-  if (options.prune && !existsSync20(lockPath)) {
+  if (options.prune && !existsSync21(lockPath)) {
     throw new Error(`Refusing to prune without an existing lockfile at ${path26.resolve(lockPath)}`);
   }
   const contentDir = path26.resolve(path26.dirname(lockPath), ".pixelkiln", "cache");
@@ -12409,7 +12616,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
 async function inspectContentCache(contentDir, referenced) {
   const report = {
     path: contentDir,
-    exists: existsSync20(contentDir),
+    exists: existsSync21(contentDir),
     files: 0,
     bytes: 0,
     valid: 0,
@@ -12473,7 +12680,7 @@ async function inspectContentCache(contentDir, referenced) {
 async function inspectRemoteHashCache(remotePath) {
   const report = {
     path: remotePath,
-    exists: existsSync20(remotePath),
+    exists: existsSync21(remotePath),
     entries: 0,
     valid: 0,
     invalidIds: [],
@@ -12523,8 +12730,11 @@ function normalizeTileRules(raw) {
   };
 }
 function exportTileset(entry, spec, options) {
-  const outputs = resolveSpecEntryOutputs(entry, spec);
+  let outputs = resolveSpecEntryOutputs(entry, spec);
   if (!outputs.length) throw new Error(`${spec.styleId}/${spec.assetId} has no downloaded outputs`);
+  if (spec.source && sourceIsStem(spec.source, entry, options.manifestDir)) {
+    outputs = outputs.map((output) => ({ ...output, absolutePath: sourceOutputPath(spec.source, entry, output.index, options.manifestDir) }));
+  }
   const packed = packSprites(
     outputs.map((output) => ({
       id: output.role ?? fallbackOutputRole(output.index),
@@ -13018,7 +13228,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 
 // src/recipes.ts
 import path28 from "path";
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { readdir as readdir3, readFile as readFile23 } from "fs/promises";
 import { fileURLToPath } from "url";
 import { z as z9 } from "zod";
@@ -13221,7 +13431,7 @@ async function readRecipeFile(recipePath, bundled) {
   return { recipe: parsed.data, path: absolute, dir: path28.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
-  if (!existsSync21(root)) return [];
+  if (!existsSync22(root)) return [];
   const out = [];
   for (const entry of await readdir3(root, { withFileTypes: true })) {
     const resolved = path28.join(root, entry.name);
@@ -13259,7 +13469,7 @@ function parseSelector(selector) {
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   const local = path28.resolve(target);
-  if (existsSync21(local)) {
+  if (existsSync22(local)) {
     const recipePath = path28.basename(local) === RECIPE_FILE ? local : path28.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
@@ -13275,7 +13485,7 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
 }
 async function verifyFile(root, file) {
   const absolute = path28.resolve(root, ...file.path.split("/"));
-  if (!existsSync21(absolute)) {
+  if (!existsSync22(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
   const actualSha256 = await sha256File(absolute);
@@ -13353,7 +13563,7 @@ async function installRecipe(target, options = {}) {
   })));
   if (!options.force) {
     for (const file of files) {
-      if (!existsSync21(file.path)) continue;
+      if (!existsSync22(file.path)) continue;
       const current = await readFile23(file.path);
       if (!current.equals(file.data)) {
         throw new Error(
@@ -13378,7 +13588,7 @@ async function installRecipe(target, options = {}) {
 
 // src/pipeline/quality-regression.ts
 import path29 from "path";
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { readFile as readFile24 } from "fs/promises";
 import { z as z10 } from "zod";
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
@@ -13621,7 +13831,7 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
     cases
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
-  if (existsSync22(absolute) && !options.force) {
+  if (existsSync23(absolute) && !options.force) {
     const current = await readFile24(absolute);
     if (!current.equals(data)) {
       throw new Error(`Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`);
@@ -13862,7 +14072,7 @@ async function provenanceFile(id, file) {
   return {
     id,
     path: absolute,
-    sha256: existsSync23(absolute) ? await sha256File(absolute) : null,
+    sha256: existsSync24(absolute) ? await sha256File(absolute) : null,
     included: true
   };
 }
@@ -14502,7 +14712,7 @@ async function confirm(question, auto) {
   return answer === "y" || answer === "yes";
 }
 async function requireCompleteWorkspaceClaims(workspacePath) {
-  if (!existsSync23(workspacePath)) {
+  if (!existsSync24(workspacePath)) {
     throw new Error(`Workspace catalog not found: ${workspacePath}`);
   }
   const dir = path30.dirname(path30.resolve(workspacePath));
@@ -14761,7 +14971,7 @@ async function main() {
   if (args.command === "init") {
     if (!args.from) throw new Error("init needs --from <dir> pointing at your existing PNGs.");
     const root = path30.resolve(args.from);
-    if (!existsSync23(root)) throw new Error(`No directory at ${root}`);
+    if (!existsSync24(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}".`);
@@ -14881,7 +15091,7 @@ async function main() {
       log(`  registered "${id}" in ${path30.relative(process.cwd(), workspacePath)}`);
       log(`    manifest: ${project.manifest}`);
       log(`    lock:     ${project.lock}`);
-      if (!existsSync23(lockPath)) {
+      if (!existsSync24(lockPath)) {
         log(
           `  warning: no lockfile there yet \u2014 this project contributes no claims until one is generated`
         );
@@ -14905,7 +15115,7 @@ async function main() {
       return;
     }
     if (args.subcommand === "list") {
-      if (!existsSync23(workspacePath)) {
+      if (!existsSync24(workspacePath)) {
         throw new Error(`Workspace catalog not found: ${workspacePath}`);
       }
       const ws = await loadWorkspace(workspacePath);
@@ -14925,7 +15135,7 @@ async function main() {
       return;
     }
     if (args.subcommand === "status") {
-      if (!existsSync23(workspacePath)) {
+      if (!existsSync24(workspacePath)) {
         throw new Error(`Workspace catalog not found: ${workspacePath}`);
       }
       const ws = await loadWorkspace(workspacePath);
@@ -14981,7 +15191,7 @@ async function main() {
   }
   if (args.command === "gallery" && args.workspace) {
     const workspacePath = path30.resolve(args.workspace);
-    if (!existsSync23(workspacePath)) {
+    if (!existsSync24(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const filter = { styles: args.styles, assets: args.assets };
@@ -15016,7 +15226,7 @@ async function main() {
     });
     return;
   }
-  if (!existsSync23(path30.resolve(args.manifest))) {
+  if (!existsSync24(path30.resolve(args.manifest))) {
     throw new Error(
       `No manifest at ${path30.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
     );
@@ -15121,12 +15331,15 @@ async function main() {
       return;
     }
     const started = await startHandEdit(loaded, lock, spec);
-    log(`  ${started.created ? "created" : "found"} ${started.source}${started.declared ? " and declared it as the asset's source" : ""}`);
+    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 ?? ""}  ${path30.relative(process.cwd(), member.path)}`);
     if (args.noOpen) {
-      log(`  edit it with your own tool, then run pixelkiln plan; mount and pack place it in place of the generated art`);
+      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 {
-      const command = openInEditor(started.editPath);
-      log(`  opened with: ${command}${process.env.PIXELKILN_EDITOR ? "" : " (set PIXELKILN_EDITOR to choose the program)"}`);
+      const command = openInEditor(started.members[0].path);
+      log(`  opened ${set ? `the first ${kind === "frames" ? "frame" : "member"} ` : ""}with: ${command}${process.env.PIXELKILN_EDITOR ? "" : " (set PIXELKILN_EDITOR to choose the program)"}`);
     }
     return;
   }
@@ -15262,7 +15475,7 @@ async function main() {
       let intact = true;
       for (const output of entry.outputs) {
         const file = resolveOutputPath(output.path, item.spec.root);
-        if (!existsSync23(file) || await sha256File(file) !== output.sha256) {
+        if (!existsSync24(file) || await sha256File(file) !== output.sha256) {
           intact = false;
           break;
         }
@@ -15644,7 +15857,7 @@ async function main() {
     const lockPaths = [
       .../* @__PURE__ */ new Set([
         ...workspaceLockPaths,
-        ...existsSync23(ownLock) ? [ownLock] : [],
+        ...existsSync24(ownLock) ? [ownLock] : [],
         ...args.claims.map((c) => path30.resolve(c))
       ])
     ];