pixelkiln 0.81.0 → 0.83.0

package/dist/index.js

@@ -14931,7 +14931,7 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 // src/gallery/snapshot.ts
 import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync25 } from "fs";
-import { readFile as readFile22, stat as stat3 } from "fs/promises";
+import { readFile as readFile23, stat as stat3 } from "fs/promises";
 import path31 from "path";
 
 // src/workspace.ts
@@ -15068,6 +15068,7 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
+import { readFile as readFile22, rename as rename9, writeFile as writeFile14 } from "fs/promises";
 import path30 from "path";
 import { z as z12 } from "zod";
 
@@ -15124,10 +15125,10 @@ var NewAssetSchema = z8.object({
   styles: z8.array(z8.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: z8.discriminatedUnion("mode", [
     z8.object({
@@ -15136,6 +15137,29 @@ var NewAssetSchema = z8.object({
       from: z8.string().min(1),
       strength: z8.number().min(0).max(1).optional()
     }).strict(),
+    z8.object({
+      mode: z8.literal("reduce-colors"),
+      from: z8.string().min(1),
+      /** A target colour count; the gallery leaves PixelLab's default when this is omitted. */
+      numColors: z8.number().int().min(2).max(256).optional(),
+      dithering: RevisionDitheringSchema.optional(),
+      ditheringStrength: z8.number().min(0).max(10).optional()
+    }).strict(),
+    z8.object({ mode: z8.literal("correct-pixelart"), from: z8.string().min(1), strength: z8.number().min(0).max(1).optional() }).strict(),
+    z8.object({
+      mode: z8.enum(["animate", "animate-pixminimax"]),
+      from: z8.string().min(1),
+      frames: z8.number().int().min(4).max(40).refine((n) => n % 2 === 0, "frames must be even").optional(),
+      fps: z8.number().int().min(1).max(60).optional(),
+      enhancePrompt: z8.boolean().optional(),
+      /** `animate-pixminimax` only; the loader refuses it on `animate`. */
+      direction: CharacterDirectionSchema.optional()
+    }).strict(),
+    z8.object({
+      mode: z8.literal("edit-animation"),
+      from: z8.string().min(1),
+      fps: z8.number().int().min(1).max(60).optional()
+    }).strict(),
     z8.object({
       mode: z8.literal("animate-skeleton"),
       from: z8.string().min(1),
@@ -15923,9 +15947,62 @@ var HandEditRequestSchema = z12.discriminatedUnion("action", [
     protocol: z12.number().int().positive()
   }).strict()
 ]);
+var UNDO_DEPTH = 20;
+var UndoRequestSchema = z12.object({
+  action: z12.literal("undo-edit"),
+  project: z12.string().min(1).optional(),
+  /** The manifest as the page last saw it; undo refuses a manifest someone else has changed since. */
+  expectedSha256: z12.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 path30.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 readFile22(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 writeFile14(tmp, last.before);
+      await rename9(tmp, manifestPath2);
+      stack.pop();
+      log(`  manifest edit undone in ${path30.relative(process.cwd(), manifestPath2) || manifestPath2}`);
+      return opts.reload();
+    }
+    const manifestPath = await manifestOf(body?.project);
+    const before = manifestPath ? await readFile22(manifestPath, "utf8").catch(() => null) : null;
+    const build = await apply(body);
+    if (manifestPath && before !== null) {
+      const after = await readFile22(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) {
@@ -16100,7 +16177,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([readFile22(a), readFile22(b)]);
+    const [left, right] = await Promise.all([readFile23(a), readFile23(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -16258,7 +16335,7 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await readFile22(loaded.path, "utf8");
+  const manifestText = await readFile23(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
   const cacheDir = path31.resolve(path31.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
@@ -16610,7 +16687,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await readFile22(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await readFile23(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -16775,6 +16852,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>.
@@ -16851,7 +16929,7 @@ var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download
 // src/editor/install.ts
 import { createHash as createHash5 } from "crypto";
 import { existsSync as existsSync27 } from "fs";
-import { mkdir as mkdir11, readFile as readFile23, rename as rename9, rm as rm11, stat as stat4, writeFile as writeFile14 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile24, rename as rename10, rm as rm11, stat as stat4, writeFile as writeFile15 } from "fs/promises";
 import os2 from "os";
 import path32 from "path";
 var EditorInstallError = class extends Error {
@@ -16882,7 +16960,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash5("sha256").update(await readFile23(file)).digest("hex");
+    return createHash5("sha256").update(await readFile24(file)).digest("hex");
   } catch {
     return null;
   }
@@ -16956,8 +17034,8 @@ async function installEditor(opts = {}) {
     const final = path32.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await writeFile14(tmp, bytes);
-      await rename9(tmp, final);
+      await writeFile15(tmp, bytes);
+      await rename10(tmp, final);
     } finally {
       await rm11(tmp, { force: true });
     }
@@ -17003,7 +17081,7 @@ function editorContentType(name) {
 }
 
 // src/gallery/editor.ts
-import { readFile as readFile24 } from "fs/promises";
+import { readFile as readFile25 } from "fs/promises";
 import path33 from "path";
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
@@ -17077,7 +17155,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile24(path33.join(dir, name));
+        bytes = await readFile25(path33.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -17094,7 +17172,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 import { randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
-import { readFile as readFile25 } from "fs/promises";
+import { readFile as readFile26 } from "fs/promises";
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -17275,7 +17353,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 readFile25(asset.path);
+          const bytes = await readFile26(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -17358,7 +17436,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await readFile25(asset.path);
+          bytes = await readFile26(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -17768,7 +17846,7 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-import { readFile as readFile26 } from "fs/promises";
+import { readFile as readFile27 } from "fs/promises";
 import { existsSync as existsSync28 } from "fs";
 import path34 from "path";
 function providerClaimId(provider, objectId) {
@@ -17780,7 +17858,7 @@ async function loadClaims(lockPaths, opts = {}) {
     if (!existsSync28(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile26(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile27(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -18017,7 +18095,7 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir12, writeFile as writeFile15, readFile as readFile27 } from "fs/promises";
+import { mkdir as mkdir12, writeFile as writeFile16, readFile as readFile28 } from "fs/promises";
 import path35 from "path";
 
 // src/pick/salvage-sheet.ts
@@ -18243,7 +18321,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             const rel = path35.join("_salvaged", `${assetId}.png`);
             const outFile = path35.resolve(ctx.importDir, rel);
             await mkdir12(path35.dirname(outFile), { recursive: true });
-            await writeFile15(outFile, buf);
+            await writeFile16(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -18299,9 +18377,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log, characters: characterMembers });
-      const raw = JSON.parse(await readFile27(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile28(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await writeFile15(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile16(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       if (characterAssetIds.length) result.characterAssetIds = characterAssetIds;
       return result;