pixelkiln 0.81.0 → 0.83.0

package/dist/index.cjs

@@ -15256,7 +15256,7 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 // src/gallery/snapshot.ts
 var import_node_crypto6 = require("crypto");
 var import_node_fs27 = require("fs");
-var import_promises24 = require("fs/promises");
+var import_promises25 = require("fs/promises");
 var import_node_path32 = __toESM(require("path"), 1);
 
 // src/workspace.ts
@@ -15393,6 +15393,7 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
+var import_promises24 = require("fs/promises");
 var import_node_path31 = __toESM(require("path"), 1);
 var import_zod12 = require("zod");
 
@@ -15449,10 +15450,10 @@ var NewAssetSchema = import_zod8.z.object({
   styles: import_zod8.z.array(import_zod8.z.string().min(1)).optional(),
   /**
    * A controlled regeneration of another asset in the same manifest,
-   * instead of a fresh generation. `inpaint` needs a mask upload the
-   * gallery does not offer yet, so only `image-to-image` and
-   * `animate-skeleton` (whose keypoints file the gallery writes first) can
-   * be created here; hand-edit the manifest for the other modes.
+   * instead of a fresh generation. `inpaint` needs a mask upload and
+   * `interpolate` an ending-keyframe image the gallery does not offer, so
+   * those two are hand-edited; every other mode can be created here
+   * (`animate-skeleton` after the gallery writes its keypoints file).
    */
   revision: import_zod8.z.discriminatedUnion("mode", [
     import_zod8.z.object({
@@ -15461,6 +15462,29 @@ var NewAssetSchema = import_zod8.z.object({
       from: import_zod8.z.string().min(1),
       strength: import_zod8.z.number().min(0).max(1).optional()
     }).strict(),
+    import_zod8.z.object({
+      mode: import_zod8.z.literal("reduce-colors"),
+      from: import_zod8.z.string().min(1),
+      /** A target colour count; the gallery leaves PixelLab's default when this is omitted. */
+      numColors: import_zod8.z.number().int().min(2).max(256).optional(),
+      dithering: RevisionDitheringSchema.optional(),
+      ditheringStrength: import_zod8.z.number().min(0).max(10).optional()
+    }).strict(),
+    import_zod8.z.object({ mode: import_zod8.z.literal("correct-pixelart"), from: import_zod8.z.string().min(1), strength: import_zod8.z.number().min(0).max(1).optional() }).strict(),
+    import_zod8.z.object({
+      mode: import_zod8.z.enum(["animate", "animate-pixminimax"]),
+      from: import_zod8.z.string().min(1),
+      frames: import_zod8.z.number().int().min(4).max(40).refine((n) => n % 2 === 0, "frames must be even").optional(),
+      fps: import_zod8.z.number().int().min(1).max(60).optional(),
+      enhancePrompt: import_zod8.z.boolean().optional(),
+      /** `animate-pixminimax` only; the loader refuses it on `animate`. */
+      direction: CharacterDirectionSchema.optional()
+    }).strict(),
+    import_zod8.z.object({
+      mode: import_zod8.z.literal("edit-animation"),
+      from: import_zod8.z.string().min(1),
+      fps: import_zod8.z.number().int().min(1).max(60).optional()
+    }).strict(),
     import_zod8.z.object({
       mode: import_zod8.z.literal("animate-skeleton"),
       from: import_zod8.z.string().min(1),
@@ -16248,9 +16272,62 @@ var HandEditRequestSchema = import_zod12.z.discriminatedUnion("action", [
     protocol: import_zod12.z.number().int().positive()
   }).strict()
 ]);
+var UNDO_DEPTH = 20;
+var UndoRequestSchema = import_zod12.z.object({
+  action: import_zod12.z.literal("undo-edit"),
+  project: import_zod12.z.string().min(1).optional(),
+  /** The manifest as the page last saw it; undo refuses a manifest someone else has changed since. */
+  expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
 function createGalleryEditHandler(opts) {
   const log = opts.onProgress ?? (() => {
   });
+  const apply = createEditApplier(opts, log);
+  const history = /* @__PURE__ */ new Map();
+  const manifestOf = async (project) => {
+    try {
+      return import_node_path31.default.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
+    } catch {
+      return null;
+    }
+  };
+  return async (body) => {
+    const undo = UndoRequestSchema.safeParse(body);
+    if (undo.success) {
+      const manifestPath2 = await manifestOf(undo.data.project);
+      if (!manifestPath2) throw new ManifestEditError("no manifest to undo an edit in");
+      const current = await (0, import_promises24.readFile)(manifestPath2, "utf8");
+      if (sha256(current) !== undo.data.expectedSha256) throw new ManifestDriftError(manifestPath2);
+      const stack = history.get(manifestPath2) ?? [];
+      const last = stack[stack.length - 1];
+      if (!last) throw new ManifestEditError("nothing to undo: this gallery has not changed the manifest");
+      if (last.afterSha !== sha256(current)) {
+        history.delete(manifestPath2);
+        throw Object.assign(new Error("the manifest changed outside the gallery since its last edit; undo would discard that change"), { status: 409 });
+      }
+      const tmp = manifestPath2 + ".pixelkiln-undo";
+      await (0, import_promises24.writeFile)(tmp, last.before);
+      await (0, import_promises24.rename)(tmp, manifestPath2);
+      stack.pop();
+      log(`  manifest edit undone in ${import_node_path31.default.relative(process.cwd(), manifestPath2) || manifestPath2}`);
+      return opts.reload();
+    }
+    const manifestPath = await manifestOf(body?.project);
+    const before = manifestPath ? await (0, import_promises24.readFile)(manifestPath, "utf8").catch(() => null) : null;
+    const build = await apply(body);
+    if (manifestPath && before !== null) {
+      const after = await (0, import_promises24.readFile)(manifestPath, "utf8").catch(() => null);
+      if (after !== null && after !== before) {
+        const stack = history.get(manifestPath) ?? [];
+        stack.push({ before, afterSha: sha256(after) });
+        if (stack.length > UNDO_DEPTH) stack.shift();
+        history.set(manifestPath, stack);
+      }
+    }
+    return build;
+  };
+}
+function createEditApplier(opts, log) {
   return async (body) => {
     const handEdit = HandEditRequestSchema.safeParse(body);
     if (handEdit.success) {
@@ -16425,7 +16502,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([(0, import_promises24.readFile)(a), (0, import_promises24.readFile)(b)]);
+    const [left, right] = await Promise.all([(0, import_promises25.readFile)(a), (0, import_promises25.readFile)(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -16491,7 +16568,7 @@ function describeCharacter(spec, entry) {
 }
 async function fileInfo(absolutePath) {
   try {
-    const info = await (0, import_promises24.stat)(absolutePath);
+    const info = await (0, import_promises25.stat)(absolutePath);
     return info.isFile() ? { bytes: info.size, modifiedAt: info.mtime.toISOString() } : null;
   } catch {
     return null;
@@ -16583,7 +16660,7 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await (0, import_promises24.readFile)(loaded.path, "utf8");
+  const manifestText = await (0, import_promises25.readFile)(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
   const cacheDir = import_node_path32.default.resolve(import_node_path32.default.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
@@ -16935,7 +17012,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises24.readFile)(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises25.readFile)(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -17100,6 +17177,7 @@ ${css}</style>
 </header>
 <main id="root"></main>
 <div id="selbar" class="selbar" hidden></div>
+<div id="toast" class="toast" role="status" aria-live="polite" hidden></div>
 <footer>
   Click a sprite for its full record; press <kbd>?</kbd> for every keyboard shortcut. This page reads the manifest, lockfile,
   and disk only. It never contacts a provider<span id="foot-edit"> and never writes anything</span><span id="foot-editing" hidden>.
@@ -17176,7 +17254,7 @@ var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download
 // src/editor/install.ts
 var import_node_crypto7 = require("crypto");
 var import_node_fs29 = require("fs");
-var import_promises25 = require("fs/promises");
+var import_promises26 = require("fs/promises");
 var import_node_os3 = __toESM(require("os"), 1);
 var import_node_path33 = __toESM(require("path"), 1);
 var EditorInstallError = class extends Error {
@@ -17207,7 +17285,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises25.readFile)(file)).digest("hex");
+    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises26.readFile)(file)).digest("hex");
   } catch {
     return null;
   }
@@ -17221,7 +17299,7 @@ async function editorStatus(opts = {}) {
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
     const file = import_node_path33.default.join(dir, name);
-    const info = (0, import_node_fs29.existsSync)(file) ? await (0, import_promises25.stat)(file).catch(() => null) : null;
+    const info = (0, import_node_fs29.existsSync)(file) ? await (0, import_promises26.stat)(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -17250,7 +17328,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await (0, import_promises25.mkdir)(dir, { recursive: true });
+  await (0, import_promises26.mkdir)(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -17281,10 +17359,10 @@ async function installEditor(opts = {}) {
     const final = import_node_path33.default.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await (0, import_promises25.writeFile)(tmp, bytes);
-      await (0, import_promises25.rename)(tmp, final);
+      await (0, import_promises26.writeFile)(tmp, bytes);
+      await (0, import_promises26.rename)(tmp, final);
     } finally {
-      await (0, import_promises25.rm)(tmp, { force: true });
+      await (0, import_promises26.rm)(tmp, { force: true });
     }
     fetchedBytes += bytes.length;
     downloaded.push(name);
@@ -17328,7 +17406,7 @@ function editorContentType(name) {
 }
 
 // src/gallery/editor.ts
-var import_promises26 = require("fs/promises");
+var import_promises27 = require("fs/promises");
 var import_node_path34 = __toESM(require("path"), 1);
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
@@ -17402,7 +17480,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await (0, import_promises26.readFile)(import_node_path34.default.join(dir, name));
+        bytes = await (0, import_promises27.readFile)(import_node_path34.default.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -17419,7 +17497,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 var import_node_crypto8 = require("crypto");
 var import_node_http2 = require("http");
-var import_promises27 = require("fs/promises");
+var import_promises28 = require("fs/promises");
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -17600,7 +17678,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 (0, import_promises27.readFile)(asset.path);
+          const bytes = await (0, import_promises28.readFile)(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -17683,7 +17761,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await (0, import_promises27.readFile)(asset.path);
+          bytes = await (0, import_promises28.readFile)(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -18093,7 +18171,7 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-var import_promises28 = require("fs/promises");
+var import_promises29 = require("fs/promises");
 var import_node_fs30 = require("fs");
 var import_node_path35 = __toESM(require("path"), 1);
 function providerClaimId(provider, objectId) {
@@ -18105,7 +18183,7 @@ async function loadClaims(lockPaths, opts = {}) {
     if (!(0, import_node_fs30.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await (0, import_promises28.readFile)(p, "utf8")));
+      parsed = parseLock(JSON.parse(await (0, import_promises29.readFile)(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -18342,7 +18420,7 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-var import_promises29 = require("fs/promises");
+var import_promises30 = require("fs/promises");
 var import_node_path36 = __toESM(require("path"), 1);
 
 // src/pick/salvage-sheet.ts
@@ -18567,8 +18645,8 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             const assetId = idFromPrompt(orphan.prompt, taken);
             const rel = import_node_path36.default.join("_salvaged", `${assetId}.png`);
             const outFile = import_node_path36.default.resolve(ctx.importDir, rel);
-            await (0, import_promises29.mkdir)(import_node_path36.default.dirname(outFile), { recursive: true });
-            await (0, import_promises29.writeFile)(outFile, buf);
+            await (0, import_promises30.mkdir)(import_node_path36.default.dirname(outFile), { recursive: true });
+            await (0, import_promises30.writeFile)(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -18624,9 +18702,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log, characters: characterMembers });
-      const raw = JSON.parse(await (0, import_promises29.readFile)(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await (0, import_promises30.readFile)(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await (0, import_promises29.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await (0, import_promises30.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       if (characterAssetIds.length) result.characterAssetIds = characterAssetIds;
       return result;