pixelkiln 0.69.0 → 0.70.0

package/dist/index.cjs

@@ -2055,9 +2055,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path34, init) {
+  async request(path35, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path34}`, {
+    const res = await this.http(`${BASE}${path35}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -2067,13 +2067,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path34} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path35} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path34} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path35} returned invalid JSON`);
     }
   }
   async balance() {
@@ -2465,10 +2465,10 @@ var PixelLabClient = class {
     const palette = args.paletteSwatchBase64 ? { color_image: { type: "base64", base64: args.paletteSwatchBase64, format: "png" }, force_colors: true } : {};
     const encode = (image) => ({ type: "base64", base64: image.base64, format: image.format });
     const south = args.reference?.south;
-    let path34;
+    let path35;
     let body;
     if (args.mode === "v3") {
-      path34 = "/create-character-v3";
+      path35 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2482,7 +2482,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path34 = "/create-character-pro-flash";
+      path35 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -2506,7 +2506,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path34 = "/create-character-pro";
+      path35 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2520,7 +2520,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path34 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path35 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2537,8 +2537,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path34, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path34.slice(1));
+    const raw = await this.request(path35, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path35.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -3716,10 +3716,10 @@ var import_node_fs = require("fs");
 function sha256(data) {
   return (0, import_node_crypto.createHash)("sha256").update(data).digest("hex");
 }
-async function sha256File(path34) {
+async function sha256File(path35) {
   return new Promise((resolve, reject) => {
     const hash = (0, import_node_crypto.createHash)("sha256");
-    const stream = (0, import_node_fs.createReadStream)(path34);
+    const stream = (0, import_node_fs.createReadStream)(path35);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -6082,9 +6082,9 @@ var RetroDiffusionClient = class {
     if (!response.ok) throw new ProviderError("retrodiffusion", `Retro Diffusion download failed (${response.status})`, { status: response.status });
     return Buffer.from(await response.arrayBuffer());
   }
-  async call(path34, init = {}) {
+  async call(path35, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path34}`, {
+    const response = await this.request(`${this.baseUrl}${path35}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -12373,10 +12373,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path34) {
-  if (!(0, import_node_fs14.existsSync)(path34)) return { version: 1, hashes: {} };
+async function loadCache(path35) {
+  if (!(0, import_node_fs14.existsSync)(path35)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises11.readFile)(path34, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises11.readFile)(path35, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12388,18 +12388,18 @@ async function loadCache(path34) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path34, cache) {
+async function saveCache(path35, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await (0, import_promises11.mkdir)(import_node_path18.default.dirname(import_node_path18.default.resolve(path34)), { recursive: true });
-  const tmp = `${path34}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await (0, import_promises11.mkdir)(import_node_path18.default.dirname(import_node_path18.default.resolve(path35)), { recursive: true });
+  const tmp = `${path35}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await (0, import_promises11.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await (0, import_promises11.rename)(tmp, path34);
+    await (0, import_promises11.rename)(tmp, path35);
   } finally {
     await (0, import_promises11.rm)(tmp, { force: true });
   }
@@ -15204,9 +15204,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 var import_node_crypto6 = require("crypto");
-var import_node_fs25 = require("fs");
-var import_promises22 = require("fs/promises");
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_fs26 = require("fs");
+var import_promises23 = require("fs/promises");
+var import_node_path31 = __toESM(require("path"), 1);
 
 // src/workspace.ts
 var import_promises19 = require("fs/promises");
@@ -15342,8 +15342,8 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
-var import_node_path29 = __toESM(require("path"), 1);
-var import_zod10 = require("zod");
+var import_node_path30 = __toESM(require("path"), 1);
+var import_zod11 = require("zod");
 
 // src/manifest-edit.ts
 var import_promises20 = require("fs/promises");
@@ -15391,15 +15391,27 @@ var NewAssetSchema = import_zod8.z.object({
   /**
    * 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` can be created
-   * here; hand-edit the manifest for the other modes.
+   * 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.
    */
-  revision: import_zod8.z.object({
-    mode: import_zod8.z.literal("image-to-image"),
-    /** Asset id of the parent this revises; must already exist. */
-    from: import_zod8.z.string().min(1),
-    strength: import_zod8.z.number().min(0).max(1).optional()
-  }).strict().optional(),
+  revision: import_zod8.z.discriminatedUnion("mode", [
+    import_zod8.z.object({
+      mode: import_zod8.z.literal("image-to-image"),
+      /** Asset id of the parent this revises; must already exist. */
+      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("animate-skeleton"),
+      from: import_zod8.z.string().min(1),
+      /** Manifest-relative; checked when the manifest is loaded, like every revision input. */
+      keypointsFile: import_zod8.z.string().min(1),
+      direction: CharacterDirectionSchema,
+      description: import_zod8.z.string().min(1).optional(),
+      skeletonTemplate: import_zod8.z.string().min(1).optional()
+    }).strict()
+  ]).optional(),
   /** A pose or outfit of an existing `character`/`objectPro` base or state. */
   state: NewStateSchema.optional(),
   /** A loop of an existing `character`/`objectPro` base or state. */
@@ -15903,41 +15915,118 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
   return openExternal(file, command);
 }
 
+// src/gallery/skeleton.ts
+var import_node_fs25 = require("fs");
+var import_promises22 = require("fs/promises");
+var import_node_path29 = __toESM(require("path"), 1);
+var import_zod10 = require("zod");
+var SkeletonEstimateRequestSchema = import_zod10.z.object({
+  project: import_zod10.z.string().min(1).optional(),
+  styleId: import_zod10.z.string().min(1),
+  assetId: import_zod10.z.string().min(1),
+  frames: import_zod10.z.number().int().min(3).max(15).optional()
+}).strict();
+var SkeletonAnimationRequestSchema = import_zod10.z.object({
+  action: import_zod10.z.literal("create-skeleton-animation"),
+  project: import_zod10.z.string().min(1).optional(),
+  expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/),
+  styleId: import_zod10.z.string().min(1),
+  /** The sprite the animation poses. */
+  from: import_zod10.z.string().min(1),
+  assetId: import_zod10.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  /** The motion, sent as PixelLab's `action`. */
+  prompt: import_zod10.z.string().min(1),
+  direction: CharacterDirectionSchema,
+  description: import_zod10.z.string().min(1).optional(),
+  skeletonTemplate: import_zod10.z.string().min(1).optional(),
+  /** Manifest-relative JSON path inside the project. */
+  keypointsFile: import_zod10.z.string().min(1),
+  /** Poses to write to `keypointsFile`; omitted to use a file that already exists. */
+  set: SkeletonSetSchema.optional(),
+  /** Replace an existing `keypointsFile` with `set`. */
+  overwrite: import_zod10.z.boolean().optional()
+}).strict();
+async function createSkeletonAnimation(manifestPath, request) {
+  const root = import_node_path29.default.dirname(import_node_path29.default.resolve(manifestPath));
+  const file = import_node_path29.default.resolve(root, request.keypointsFile);
+  const relative = import_node_path29.default.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || import_node_path29.default.isAbsolute(relative)) {
+    throw new ManifestEditError("the keypoints file must be a .json path inside the project");
+  }
+  const existed = (0, import_node_fs25.existsSync)(file);
+  let previous = null;
+  if (request.set) {
+    if (existed && !request.overwrite) {
+      throw new ManifestEditError(`${request.keypointsFile} already exists; choose another path, or replace it`);
+    }
+    if (existed) previous = await (0, import_promises22.readFile)(file);
+    await (0, import_promises22.mkdir)(import_node_path29.default.dirname(file), { recursive: true });
+    await (0, import_promises22.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
+  } else if (!existed) {
+    throw new ManifestEditError(`${request.keypointsFile} does not exist; paste poses or estimate them from the sprite`);
+  }
+  try {
+    await applyManifestEdit(manifestPath, {
+      action: "add-asset",
+      assetId: request.assetId,
+      expectedSha256: request.expectedSha256,
+      asset: {
+        prompt: request.prompt,
+        styles: [request.styleId],
+        revision: {
+          mode: "animate-skeleton",
+          from: request.from,
+          keypointsFile: relative.split(import_node_path29.default.sep).join("/"),
+          direction: request.direction,
+          ...request.description ? { description: request.description } : {},
+          ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
+        }
+      }
+    });
+  } catch (error) {
+    if (request.set) {
+      if (previous) await (0, import_promises22.writeFile)(file, previous);
+      else await (0, import_promises22.rm)(file, { force: true });
+    }
+    throw error;
+  }
+}
+
 // src/gallery/edit.ts
-var Base64 = import_zod10.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = import_zod10.z.discriminatedUnion("action", [
-  import_zod10.z.object({
-    action: import_zod10.z.literal("start-edit"),
-    project: import_zod10.z.string().min(1).optional(),
-    assetId: import_zod10.z.string().min(1),
-    styleId: import_zod10.z.string().min(1),
-    expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/),
+var Base64 = import_zod11.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = import_zod11.z.discriminatedUnion("action", [
+  import_zod11.z.object({
+    action: import_zod11.z.literal("start-edit"),
+    project: import_zod11.z.string().min(1).optional(),
+    assetId: import_zod11.z.string().min(1),
+    styleId: import_zod11.z.string().min(1),
+    expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: import_zod10.z.boolean().optional()
+    open: import_zod11.z.boolean().optional()
   }).strict(),
-  import_zod10.z.object({
-    action: import_zod10.z.literal("detach-edit"),
-    project: import_zod10.z.string().min(1).optional(),
-    assetId: import_zod10.z.string().min(1),
-    styleId: import_zod10.z.string().min(1),
-    expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/)
+  import_zod11.z.object({
+    action: import_zod11.z.literal("detach-edit"),
+    project: import_zod11.z.string().min(1).optional(),
+    assetId: import_zod11.z.string().min(1),
+    styleId: import_zod11.z.string().min(1),
+    expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  import_zod10.z.object({
-    action: import_zod10.z.literal("save-edit"),
-    project: import_zod10.z.string().min(1).optional(),
-    assetId: import_zod10.z.string().min(1),
-    styleId: import_zod10.z.string().min(1),
-    expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/),
+  import_zod11.z.object({
+    action: import_zod11.z.literal("save-edit"),
+    project: import_zod11.z.string().min(1).optional(),
+    assetId: import_zod11.z.string().min(1),
+    styleId: import_zod11.z.string().min(1),
+    expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/),
     /** 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: import_zod10.z.array(import_zod10.z.object({ role: import_zod10.z.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: import_zod11.z.array(import_zod11.z.object({ role: import_zod11.z.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. */
-    editor: import_zod10.z.string().min(1).max(200),
-    protocol: import_zod10.z.number().int().positive()
+    editor: import_zod11.z.string().min(1).max(200),
+    protocol: import_zod11.z.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -15978,6 +16067,23 @@ function createGalleryEditHandler(opts) {
       }
       return opts.reload();
     }
+    const skeleton = SkeletonAnimationRequestSchema.safeParse(body);
+    if (skeleton.success) {
+      let manifestPath2;
+      try {
+        manifestPath2 = await opts.manifestFor(skeleton.data.project);
+      } catch (error) {
+        throw new ManifestEditError(error instanceof Error ? error.message : String(error));
+      }
+      await createSkeletonAnimation(manifestPath2, skeleton.data);
+      log(`  manifest edited: added skeleton animation ${skeleton.data.assetId} (${skeleton.data.keypointsFile})`);
+      return opts.reload();
+    }
+    if (body?.action === "create-skeleton-animation") {
+      throw new ManifestEditError(
+        "invalid skeleton animation: " + skeleton.error.issues.slice(0, 3).map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")
+      );
+    }
     const parsed = ManifestEditSchema.safeParse(body);
     if (!parsed.success) {
       throw new ManifestEditError(
@@ -15992,7 +16098,7 @@ function createGalleryEditHandler(opts) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = import_node_path29.default.relative(process.cwd(), result.manifestPath);
+      const relative = import_node_path30.default.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
       const subject = parsed.data.action === "patch-style" ? `style ${parsed.data.styleId}` : parsed.data.action === "set-source" || parsed.data.action === "clear-source" ? `${parsed.data.styleId}/${parsed.data.assetId} source` : parsed.data.assetId;
       log(`  manifest edited: ${parsed.data.action === "add-asset" ? "added" : "changed"} ${subject} in ${shown}`);
@@ -16004,7 +16110,7 @@ function createGalleryEditHandler(opts) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return (0, import_node_crypto6.createHash)("sha256").update(import_node_path30.default.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return (0, import_node_crypto6.createHash)("sha256").update(import_node_path31.default.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -16023,9 +16129,9 @@ function describeHistory(media, entry, cacheDir) {
   return (entry.history ?? []).map((generation, i) => {
     const outputs = generation.outputs.map((output) => {
       const mediaType = output.mediaType ?? MediaType.PNG;
-      const file = import_node_path30.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = import_node_path31.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if ((0, import_node_fs25.existsSync)(file)) {
+      if ((0, import_node_fs26.existsSync)(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -16057,7 +16163,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_promises22.readFile)(a), (0, import_promises22.readFile)(b)]);
+    const [left, right] = await Promise.all([(0, import_promises23.readFile)(a), (0, import_promises23.readFile)(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -16123,7 +16229,7 @@ function describeCharacter(spec, entry) {
 }
 async function fileInfo(absolutePath) {
   try {
-    const info = await (0, import_promises22.stat)(absolutePath);
+    const info = await (0, import_promises23.stat)(absolutePath);
     return info.isFile() ? { bytes: info.size, modifiedAt: info.mtime.toISOString() } : null;
   } catch {
     return null;
@@ -16155,10 +16261,10 @@ async function describeOutput(media, root, absolutePath, recorded = {}) {
 async function describeQuality(media, root, inspection) {
   const outputPaths = inspection.outputs ?? [inspection.output];
   const outputs = await Promise.all(
-    outputPaths.map((file) => describeOutput(media, root, import_node_path30.default.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, import_node_path31.default.resolve(root, file)))
   );
-  const recordPath = import_node_path30.default.resolve(root, inspection.record);
-  const recordExists = (0, import_node_fs25.existsSync)(recordPath);
+  const recordPath = import_node_path31.default.resolve(root, inspection.record);
+  const recordExists = (0, import_node_fs26.existsSync)(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -16177,7 +16283,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(import_node_path30.default.resolve(root, inspection.output), root),
+    output: portableOutputPath(import_node_path31.default.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -16215,9 +16321,9 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await (0, import_promises22.readFile)(loaded.path, "utf8");
+  const manifestText = await (0, import_promises23.readFile)(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = import_node_path30.default.resolve(import_node_path30.default.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = import_node_path31.default.resolve(import_node_path31.default.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -16241,12 +16347,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = import_node_path30.default.resolve(root, spec.source);
+        const editPath = import_node_path31.default.resolve(root, spec.source);
         const memberCount = sourceIsStem(spec.source, entry, root) ? entry.outputs.length : 1;
         const editShas = await Promise.all(
           Array.from({ length: memberCount }, async (_, index) => {
             const file = sourceOutputPath(spec.source, entry, index, root);
-            return { file, sha256: (0, import_node_fs25.existsSync)(file) ? await sha256File(file) : null };
+            return { file, sha256: (0, import_node_fs26.existsSync)(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -16254,7 +16360,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && (0, import_node_fs25.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && (0, import_node_fs26.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -16290,8 +16396,8 @@ async function buildGallerySnapshot(opts) {
         editStatus = edits.some((member) => !member.exists) ? "missing" : editChanged.every((changed) => !changed) ? "same" : regenerated ? "regenerated-since" : "edited";
       }
     } else if (spec.source) {
-      outputs = [await describeOutput(media, root, import_node_path30.default.resolve(root, spec.source))];
-    } else if (!entry && (0, import_node_fs25.existsSync)(spec.outFile)) {
+      outputs = [await describeOutput(media, root, import_node_path31.default.resolve(root, spec.source))];
+    } else if (!entry && (0, import_node_fs26.existsSync)(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -16332,6 +16438,10 @@ async function buildGallerySnapshot(opts) {
       revision: entry?.revision ?? null,
       revisionParentKey: spec.revision ? lockKey(spec.styleId, spec.revision.sourceAssetId) : entry?.revision ? lockKey(spec.styleId, entry.revision.sourceAssetId) : null,
       mirrorOfKey: spec.mirror ? lockKey(spec.styleId, spec.mirror.sourceAssetId) : entry?.mirror ? lockKey(spec.styleId, entry.mirror.sourceAssetId) : null,
+      skeleton: spec.revision?.mode === "animate-skeleton" && spec.revision.keypointsFile ? {
+        keypointsFile: portableOutputPath(spec.revision.keypointsFile, root),
+        set: spec.revision.skeleton ?? null
+      } : null,
       character: describeCharacter(spec, entry),
       outputs,
       quality,
@@ -16396,6 +16506,7 @@ async function buildGallerySnapshot(opts) {
       revision: entry.revision,
       revisionParentKey: entry.revision ? lockKey(entry.styleId, entry.revision.sourceAssetId) : null,
       mirrorOfKey: entry.mirror ? lockKey(entry.styleId, entry.mirror.sourceAssetId) : null,
+      skeleton: null,
       character: describeCharacter(void 0, entry),
       outputs,
       quality: null,
@@ -16486,7 +16597,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: import_node_path30.default.resolve(opts.lockPath),
+      lock: import_node_path31.default.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -16512,7 +16623,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = import_node_path30.default.dirname(import_node_path30.default.resolve(opts.workspacePath));
+  const dir = import_node_path31.default.dirname(import_node_path31.default.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -16555,11 +16666,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: import_node_path30.default.resolve(lockPath),
+        lock: import_node_path31.default.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises22.readFile)(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises23.readFile)(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -16571,8 +16682,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: import_node_path30.default.resolve(lockPath),
-        root: import_node_path30.default.dirname(manifestPath),
+        lock: import_node_path31.default.resolve(lockPath),
+        root: import_node_path31.default.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -16599,7 +16710,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: import_node_path30.default.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: import_node_path31.default.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -16616,13 +16727,13 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 
 // src/gallery/page.ts
-var import_node_fs26 = require("fs");
+var import_node_fs27 = require("fs");
 var CLIENT_DIR = new URL("./client/", importMetaUrl);
 var client;
 function clientAssets() {
   client ??= {
-    css: (0, import_node_fs26.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
-    js: (0, import_node_fs26.readFileSync)(new URL("gallery.js", CLIENT_DIR), "utf8")
+    css: (0, import_node_fs27.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
+    js: (0, import_node_fs27.readFileSync)(new URL("gallery.js", CLIENT_DIR), "utf8")
   };
   return client;
 }
@@ -16748,10 +16859,10 @@ var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download
 
 // src/editor/install.ts
 var import_node_crypto7 = require("crypto");
-var import_node_fs27 = require("fs");
-var import_promises23 = require("fs/promises");
+var import_node_fs28 = require("fs");
+var import_promises24 = require("fs/promises");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_path32 = __toESM(require("path"), 1);
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -16762,15 +16873,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return import_node_path31.default.resolve(override);
-  if (process.platform === "darwin") return import_node_path31.default.join(import_node_os3.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return import_node_path32.default.resolve(override);
+  if (process.platform === "darwin") return import_node_path32.default.join(import_node_os3.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return import_node_path31.default.join(process.env.LOCALAPPDATA ?? import_node_path31.default.join(import_node_os3.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return import_node_path32.default.join(process.env.LOCALAPPDATA ?? import_node_path32.default.join(import_node_os3.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return import_node_path31.default.join(process.env.XDG_CACHE_HOME ?? import_node_path31.default.join(import_node_os3.default.homedir(), ".cache"), "pixelkiln", "tools");
+  return import_node_path32.default.join(process.env.XDG_CACHE_HOME ?? import_node_path32.default.join(import_node_os3.default.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return import_node_path31.default.join(root, "pixelorama", pin.release ?? "unpublished");
+  return import_node_path32.default.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -16780,7 +16891,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises23.readFile)(file)).digest("hex");
+    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises24.readFile)(file)).digest("hex");
   } catch {
     return null;
   }
@@ -16793,8 +16904,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = import_node_path31.default.join(dir, name);
-    const info = (0, import_node_fs27.existsSync)(file) ? await (0, import_promises23.stat)(file).catch(() => null) : null;
+    const file = import_node_path32.default.join(dir, name);
+    const info = (0, import_node_fs28.existsSync)(file) ? await (0, import_promises24.stat)(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -16823,7 +16934,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await (0, import_promises23.mkdir)(dir, { recursive: true });
+  await (0, import_promises24.mkdir)(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -16851,13 +16962,13 @@ async function installEditor(opts = {}) {
     if (digest2 !== expected.sha256) {
       throw new EditorInstallError(`${name}: sha256 ${digest2.slice(0, 12)}\u2026 does not match the pinned ${expected.sha256.slice(0, 12)}\u2026`, name);
     }
-    const final = import_node_path31.default.join(dir, name);
+    const final = import_node_path32.default.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await (0, import_promises23.writeFile)(tmp, bytes);
-      await (0, import_promises23.rename)(tmp, final);
+      await (0, import_promises24.writeFile)(tmp, bytes);
+      await (0, import_promises24.rename)(tmp, final);
     } finally {
-      await (0, import_promises23.rm)(tmp, { force: true });
+      await (0, import_promises24.rm)(tmp, { force: true });
     }
     fetchedBytes += bytes.length;
     downloaded.push(name);
@@ -16897,12 +17008,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[import_node_path31.default.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[import_node_path32.default.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
-var import_promises24 = require("fs/promises");
-var import_node_path32 = __toESM(require("path"), 1);
+var import_promises25 = require("fs/promises");
+var import_node_path33 = __toESM(require("path"), 1);
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -16975,7 +17086,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await (0, import_promises24.readFile)(import_node_path32.default.join(dir, name));
+        bytes = await (0, import_promises25.readFile)(import_node_path33.default.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -16992,7 +17103,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 var import_node_crypto8 = require("crypto");
 var import_node_http2 = require("http");
-var import_promises25 = require("fs/promises");
+var import_promises26 = require("fs/promises");
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -17020,7 +17131,7 @@ async function readJsonBody(req) {
 async function serveGallery(opts) {
   const log = opts.onProgress ?? (() => {
   });
-  const session = opts.edit || opts.generate || opts.editor ? (0, import_node_crypto8.randomBytes)(16).toString("hex") : null;
+  const session = opts.edit || opts.generate || opts.editor || opts.skeleton ? (0, import_node_crypto8.randomBytes)(16).toString("hex") : null;
   let media = /* @__PURE__ */ new Map();
   let loading = null;
   const reviewAssets = /* @__PURE__ */ new Map();
@@ -17095,6 +17206,17 @@ async function serveGallery(opts) {
       }
       return;
     }
+    if (req.method === "POST" && url2.pathname === "/api/skeleton/estimate") {
+      if (!opts.skeleton || !session) return fail(405, "skeleton estimates need the gallery started with --edit");
+      try {
+        const body = await guardedBody("skeleton estimates");
+        if (body === void 0) return;
+        json(200, await opts.skeleton.estimate(body));
+      } catch (err) {
+        reportError("skeleton estimate", err);
+      }
+      return;
+    }
     if (req.method === "POST" && url2.pathname === "/api/editor/install") {
       if (!opts.editor || !session) return fail(405, "the in-browser editor is off for this gallery");
       try {
@@ -17151,7 +17273,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_promises25.readFile)(asset.path);
+          const bytes = await (0, import_promises26.readFile)(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -17227,7 +17349,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await (0, import_promises25.readFile)(asset.path);
+          bytes = await (0, import_promises26.readFile)(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -17271,27 +17393,27 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 var import_node_crypto9 = require("crypto");
-var import_zod11 = require("zod");
-var GenerateRequestSchema = import_zod11.z.object({
-  project: import_zod11.z.string().min(1).optional(),
-  keys: import_zod11.z.array(import_zod11.z.string().min(1)).min(1).max(500),
+var import_zod12 = require("zod");
+var GenerateRequestSchema = import_zod12.z.object({
+  project: import_zod12.z.string().min(1).optional(),
+  keys: import_zod12.z.array(import_zod12.z.string().min(1)).min(1).max(500),
   /**
    * Regenerate work that is up to date, as `gen --force` does, and let the
    * fetch replace a locally modified or untracked file. With `restore`, put
    * the recorded bytes back over a modified file.
    */
-  force: import_zod11.z.boolean().optional(),
+  force: import_zod12.z.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: import_zod11.z.boolean().optional(),
+  resume: import_zod12.z.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: import_zod11.z.boolean().optional(),
+  refresh: import_zod12.z.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: import_zod11.z.boolean().optional(),
+  restore: import_zod12.z.boolean().optional(),
   /**
    * Bring a replaced generation back: 1-based position in the record's
    * history (newest first) or an output hash prefix. One key at a time.
    */
-  revert: import_zod11.z.string().min(1).max(64).optional()
+  revert: import_zod12.z.string().min(1).max(64).optional()
 }).strict().refine((request) => [request.resume, request.refresh, request.restore, request.revert !== void 0].filter(Boolean).length <= 1, {
   message: "resume, refresh, restore, and revert are exclusive"
 }).refine((request) => request.revert === void 0 || request.keys.length === 1, { message: "revert takes one key" });
@@ -17601,19 +17723,19 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-var import_promises26 = require("fs/promises");
-var import_node_fs28 = require("fs");
-var import_node_path33 = __toESM(require("path"), 1);
+var import_promises27 = require("fs/promises");
+var import_node_fs29 = require("fs");
+var import_node_path34 = __toESM(require("path"), 1);
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
 async function loadClaims(lockPaths, opts = {}) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
-    if (!(0, import_node_fs28.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!(0, import_node_fs29.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await (0, import_promises26.readFile)(p, "utf8")));
+      parsed = parseLock(JSON.parse(await (0, import_promises27.readFile)(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -17717,20 +17839,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = import_node_path33.default.resolve(ownManifestPath);
+  const own = import_node_path34.default.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => import_node_path33.default.join(import_node_path33.default.dirname(import_node_path33.default.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => import_node_path34.default.join(import_node_path34.default.dirname(import_node_path34.default.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (import_node_path33.default.resolve(siblingManifestPath) === own) continue;
-    if (!(0, import_node_fs28.existsSync)(siblingManifestPath)) continue;
+    if (import_node_path34.default.resolve(siblingManifestPath) === own) continue;
+    if (!(0, import_node_fs29.existsSync)(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: import_node_path33.default.basename(import_node_path33.default.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: import_node_path34.default.basename(import_node_path34.default.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -17850,8 +17972,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-var import_promises27 = require("fs/promises");
-var import_node_path34 = __toESM(require("path"), 1);
+var import_promises28 = require("fs/promises");
+var import_node_path35 = __toESM(require("path"), 1);
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -18017,7 +18139,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: import_node_path34.default.relative(process.cwd(), ctx.importDir) || "."
+    importDir: import_node_path35.default.relative(process.cwd(), ctx.importDir) || "."
   });
   const byId = new Map(orphans.map((o) => [o.id, o]));
   const existingTags = new Map(orphans.map((o) => [o.id, o.tags]));
@@ -18073,10 +18195,10 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE2)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = import_node_path34.default.join("_salvaged", `${assetId}.png`);
-            const outFile = import_node_path34.default.resolve(ctx.importDir, rel);
-            await (0, import_promises27.mkdir)(import_node_path34.default.dirname(outFile), { recursive: true });
-            await (0, import_promises27.writeFile)(outFile, buf);
+            const rel = import_node_path35.default.join("_salvaged", `${assetId}.png`);
+            const outFile = import_node_path35.default.resolve(ctx.importDir, rel);
+            await (0, import_promises28.mkdir)(import_node_path35.default.dirname(outFile), { recursive: true });
+            await (0, import_promises28.writeFile)(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -18108,7 +18230,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, import_node_path34.default.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, import_node_path35.default.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -18132,9 +18254,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log, characters: characterMembers });
-      const raw = JSON.parse(await (0, import_promises27.readFile)(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await (0, import_promises28.readFile)(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await (0, import_promises27.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await (0, import_promises28.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       if (characterAssetIds.length) result.characterAssetIds = characterAssetIds;
       return result;