pixelkiln 0.69.0 → 0.70.0

package/dist/index.js

@@ -1732,9 +1732,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,
@@ -1744,13 +1744,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() {
@@ -2142,10 +2142,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,
@@ -2159,7 +2159,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,
@@ -2183,7 +2183,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path34 = "/create-character-pro";
+      path35 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2197,7 +2197,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,
@@ -2214,8 +2214,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) {
@@ -3393,10 +3393,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path34) {
+async function sha256File(path35) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path34);
+    const stream = createReadStream(path35);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -5759,9 +5759,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",
@@ -12050,10 +12050,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path34) {
-  if (!existsSync13(path34)) return { version: 1, hashes: {} };
+async function loadCache(path35) {
+  if (!existsSync13(path35)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path34, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path35, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12065,18 +12065,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 mkdir5(pathModule.dirname(pathModule.resolve(path34)), { recursive: true });
-  const tmp = `${path34}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir5(pathModule.dirname(pathModule.resolve(path35)), { recursive: true });
+  const tmp = `${path35}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile5(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename4(tmp, path34);
+    await rename4(tmp, path35);
   } finally {
     await rm4(tmp, { force: true });
   }
@@ -14881,9 +14881,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync23 } from "fs";
-import { readFile as readFile21, stat as stat3 } from "fs/promises";
-import path29 from "path";
+import { existsSync as existsSync24 } from "fs";
+import { readFile as readFile22, stat as stat3 } from "fs/promises";
+import path30 from "path";
 
 // src/workspace.ts
 import { mkdir as mkdir7, readFile as readFile18, rename as rename6, rm as rm7, writeFile as writeFile9 } from "fs/promises";
@@ -15019,8 +15019,8 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
-import path28 from "path";
-import { z as z10 } from "zod";
+import path29 from "path";
+import { z as z11 } from "zod";
 
 // src/manifest-edit.ts
 import { readFile as readFile19, rename as rename7, rm as rm8, writeFile as writeFile10 } from "fs/promises";
@@ -15068,15 +15068,27 @@ var NewAssetSchema = z8.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: z8.object({
-    mode: z8.literal("image-to-image"),
-    /** Asset id of the parent this revises; must already exist. */
-    from: z8.string().min(1),
-    strength: z8.number().min(0).max(1).optional()
-  }).strict().optional(),
+  revision: z8.discriminatedUnion("mode", [
+    z8.object({
+      mode: z8.literal("image-to-image"),
+      /** Asset id of the parent this revises; must already exist. */
+      from: z8.string().min(1),
+      strength: z8.number().min(0).max(1).optional()
+    }).strict(),
+    z8.object({
+      mode: z8.literal("animate-skeleton"),
+      from: z8.string().min(1),
+      /** Manifest-relative; checked when the manifest is loaded, like every revision input. */
+      keypointsFile: z8.string().min(1),
+      direction: CharacterDirectionSchema,
+      description: z8.string().min(1).optional(),
+      skeletonTemplate: z8.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. */
@@ -15580,41 +15592,118 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
   return openExternal(file, command);
 }
 
+// src/gallery/skeleton.ts
+import { existsSync as existsSync23 } from "fs";
+import { mkdir as mkdir9, readFile as readFile21, rm as rm10, writeFile as writeFile12 } from "fs/promises";
+import path28 from "path";
+import { z as z10 } from "zod";
+var SkeletonEstimateRequestSchema = z10.object({
+  project: z10.string().min(1).optional(),
+  styleId: z10.string().min(1),
+  assetId: z10.string().min(1),
+  frames: z10.number().int().min(3).max(15).optional()
+}).strict();
+var SkeletonAnimationRequestSchema = z10.object({
+  action: z10.literal("create-skeleton-animation"),
+  project: z10.string().min(1).optional(),
+  expectedSha256: z10.string().regex(/^[0-9a-f]{64}$/),
+  styleId: z10.string().min(1),
+  /** The sprite the animation poses. */
+  from: z10.string().min(1),
+  assetId: z10.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  /** The motion, sent as PixelLab's `action`. */
+  prompt: z10.string().min(1),
+  direction: CharacterDirectionSchema,
+  description: z10.string().min(1).optional(),
+  skeletonTemplate: z10.string().min(1).optional(),
+  /** Manifest-relative JSON path inside the project. */
+  keypointsFile: z10.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: z10.boolean().optional()
+}).strict();
+async function createSkeletonAnimation(manifestPath, request) {
+  const root = path28.dirname(path28.resolve(manifestPath));
+  const file = path28.resolve(root, request.keypointsFile);
+  const relative = path28.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || path28.isAbsolute(relative)) {
+    throw new ManifestEditError("the keypoints file must be a .json path inside the project");
+  }
+  const existed = existsSync23(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 readFile21(file);
+    await mkdir9(path28.dirname(file), { recursive: true });
+    await writeFile12(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(path28.sep).join("/"),
+          direction: request.direction,
+          ...request.description ? { description: request.description } : {},
+          ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
+        }
+      }
+    });
+  } catch (error) {
+    if (request.set) {
+      if (previous) await writeFile12(file, previous);
+      else await rm10(file, { force: true });
+    }
+    throw error;
+  }
+}
+
 // src/gallery/edit.ts
-var Base64 = z10.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = z10.discriminatedUnion("action", [
-  z10.object({
-    action: z10.literal("start-edit"),
-    project: z10.string().min(1).optional(),
-    assetId: z10.string().min(1),
-    styleId: z10.string().min(1),
-    expectedSha256: z10.string().regex(/^[0-9a-f]{64}$/),
+var Base64 = z11.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = z11.discriminatedUnion("action", [
+  z11.object({
+    action: z11.literal("start-edit"),
+    project: z11.string().min(1).optional(),
+    assetId: z11.string().min(1),
+    styleId: z11.string().min(1),
+    expectedSha256: z11.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: z10.boolean().optional()
+    open: z11.boolean().optional()
   }).strict(),
-  z10.object({
-    action: z10.literal("detach-edit"),
-    project: z10.string().min(1).optional(),
-    assetId: z10.string().min(1),
-    styleId: z10.string().min(1),
-    expectedSha256: z10.string().regex(/^[0-9a-f]{64}$/)
+  z11.object({
+    action: z11.literal("detach-edit"),
+    project: z11.string().min(1).optional(),
+    assetId: z11.string().min(1),
+    styleId: z11.string().min(1),
+    expectedSha256: z11.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  z10.object({
-    action: z10.literal("save-edit"),
-    project: z10.string().min(1).optional(),
-    assetId: z10.string().min(1),
-    styleId: z10.string().min(1),
-    expectedSha256: z10.string().regex(/^[0-9a-f]{64}$/),
+  z11.object({
+    action: z11.literal("save-edit"),
+    project: z11.string().min(1).optional(),
+    assetId: z11.string().min(1),
+    styleId: z11.string().min(1),
+    expectedSha256: z11.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: z10.array(z10.object({ role: z10.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: z11.array(z11.object({ role: z11.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: z10.string().min(1).max(200),
-    protocol: z10.number().int().positive()
+    editor: z11.string().min(1).max(200),
+    protocol: z11.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -15655,6 +15744,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(
@@ -15669,7 +15775,7 @@ function createGalleryEditHandler(opts) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = path28.relative(process.cwd(), result.manifestPath);
+      const relative = path29.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}`);
@@ -15681,7 +15787,7 @@ function createGalleryEditHandler(opts) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return createHash4("sha256").update(path29.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return createHash4("sha256").update(path30.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -15700,9 +15806,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 = path29.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = path30.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if (existsSync23(file)) {
+      if (existsSync24(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -15734,7 +15840,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([readFile21(a), readFile21(b)]);
+    const [left, right] = await Promise.all([readFile22(a), readFile22(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -15832,10 +15938,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, path29.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, path30.resolve(root, file)))
   );
-  const recordPath = path29.resolve(root, inspection.record);
-  const recordExists = existsSync23(recordPath);
+  const recordPath = path30.resolve(root, inspection.record);
+  const recordExists = existsSync24(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -15854,7 +15960,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path29.resolve(root, inspection.output), root),
+    output: portableOutputPath(path30.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -15892,9 +15998,9 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await readFile21(loaded.path, "utf8");
+  const manifestText = await readFile22(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = path29.resolve(path29.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = path30.resolve(path30.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -15918,12 +16024,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path29.resolve(root, spec.source);
+        const editPath = path30.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: existsSync23(file) ? await sha256File(file) : null };
+            return { file, sha256: existsSync24(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -15931,7 +16037,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && existsSync23(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && existsSync24(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -15967,8 +16073,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, path29.resolve(root, spec.source))];
-    } else if (!entry && existsSync23(spec.outFile)) {
+      outputs = [await describeOutput(media, root, path30.resolve(root, spec.source))];
+    } else if (!entry && existsSync24(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -16009,6 +16115,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,
@@ -16073,6 +16183,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,
@@ -16163,7 +16274,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path29.resolve(opts.lockPath),
+      lock: path30.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -16189,7 +16300,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path29.dirname(path29.resolve(opts.workspacePath));
+  const dir = path30.dirname(path30.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -16232,11 +16343,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path29.resolve(lockPath),
+        lock: path30.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await readFile21(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await readFile22(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -16248,8 +16359,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path29.resolve(lockPath),
-        root: path29.dirname(manifestPath),
+        lock: path30.resolve(lockPath),
+        root: path30.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -16276,7 +16387,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: path29.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: path30.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -16425,10 +16536,10 @@ var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download
 
 // src/editor/install.ts
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync24 } from "fs";
-import { mkdir as mkdir9, readFile as readFile22, rename as rename9, rm as rm10, stat as stat4, writeFile as writeFile12 } from "fs/promises";
+import { existsSync as existsSync25 } from "fs";
+import { mkdir as mkdir10, readFile as readFile23, rename as rename9, rm as rm11, stat as stat4, writeFile as writeFile13 } from "fs/promises";
 import os2 from "os";
-import path30 from "path";
+import path31 from "path";
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -16439,15 +16550,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return path30.resolve(override);
-  if (process.platform === "darwin") return path30.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return path31.resolve(override);
+  if (process.platform === "darwin") return path31.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return path30.join(process.env.LOCALAPPDATA ?? path30.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return path31.join(process.env.LOCALAPPDATA ?? path31.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return path30.join(process.env.XDG_CACHE_HOME ?? path30.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
+  return path31.join(process.env.XDG_CACHE_HOME ?? path31.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return path30.join(root, "pixelorama", pin.release ?? "unpublished");
+  return path31.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -16457,7 +16568,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash5("sha256").update(await readFile22(file)).digest("hex");
+    return createHash5("sha256").update(await readFile23(file)).digest("hex");
   } catch {
     return null;
   }
@@ -16470,8 +16581,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = path30.join(dir, name);
-    const info = existsSync24(file) ? await stat4(file).catch(() => null) : null;
+    const file = path31.join(dir, name);
+    const info = existsSync25(file) ? await stat4(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -16500,7 +16611,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await mkdir9(dir, { recursive: true });
+  await mkdir10(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -16528,13 +16639,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 = path30.join(dir, name);
+    const final = path31.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await writeFile12(tmp, bytes);
+      await writeFile13(tmp, bytes);
       await rename9(tmp, final);
     } finally {
-      await rm10(tmp, { force: true });
+      await rm11(tmp, { force: true });
     }
     fetchedBytes += bytes.length;
     downloaded.push(name);
@@ -16574,12 +16685,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[path30.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[path31.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
-import { readFile as readFile23 } from "fs/promises";
-import path31 from "path";
+import { readFile as readFile24 } from "fs/promises";
+import path32 from "path";
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -16652,7 +16763,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile23(path31.join(dir, name));
+        bytes = await readFile24(path32.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -16669,7 +16780,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 import { randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
-import { readFile as readFile24 } from "fs/promises";
+import { readFile as readFile25 } from "fs/promises";
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -16697,7 +16808,7 @@ async function readJsonBody(req) {
 async function serveGallery(opts) {
   const log = opts.onProgress ?? (() => {
   });
-  const session = opts.edit || opts.generate || opts.editor ? randomBytes(16).toString("hex") : null;
+  const session = opts.edit || opts.generate || opts.editor || opts.skeleton ? randomBytes(16).toString("hex") : null;
   let media = /* @__PURE__ */ new Map();
   let loading = null;
   const reviewAssets = /* @__PURE__ */ new Map();
@@ -16772,6 +16883,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 {
@@ -16828,7 +16950,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 readFile24(asset.path);
+          const bytes = await readFile25(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -16904,7 +17026,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await readFile24(asset.path);
+          bytes = await readFile25(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -16948,27 +17070,27 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { z as z11 } from "zod";
-var GenerateRequestSchema = z11.object({
-  project: z11.string().min(1).optional(),
-  keys: z11.array(z11.string().min(1)).min(1).max(500),
+import { z as z12 } from "zod";
+var GenerateRequestSchema = z12.object({
+  project: z12.string().min(1).optional(),
+  keys: z12.array(z12.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: z11.boolean().optional(),
+  force: z12.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: z11.boolean().optional(),
+  resume: z12.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: z11.boolean().optional(),
+  refresh: z12.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: z11.boolean().optional(),
+  restore: z12.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: z11.string().min(1).max(64).optional()
+  revert: z12.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" });
@@ -17278,19 +17400,19 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-import { readFile as readFile25 } from "fs/promises";
-import { existsSync as existsSync25 } from "fs";
-import path32 from "path";
+import { readFile as readFile26 } from "fs/promises";
+import { existsSync as existsSync26 } from "fs";
+import path33 from "path";
 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 (!existsSync25(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!existsSync26(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile25(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile26(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -17394,20 +17516,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path32.resolve(ownManifestPath);
+  const own = path33.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path32.join(path32.dirname(path32.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path33.join(path33.dirname(path33.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path32.resolve(siblingManifestPath) === own) continue;
-    if (!existsSync25(siblingManifestPath)) continue;
+    if (path33.resolve(siblingManifestPath) === own) continue;
+    if (!existsSync26(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path32.basename(path32.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path33.basename(path33.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -17527,8 +17649,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir10, writeFile as writeFile13, readFile as readFile26 } from "fs/promises";
-import path33 from "path";
+import { mkdir as mkdir11, writeFile as writeFile14, readFile as readFile27 } from "fs/promises";
+import path34 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -17694,7 +17816,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path33.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path34.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]));
@@ -17750,10 +17872,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 = path33.join("_salvaged", `${assetId}.png`);
-            const outFile = path33.resolve(ctx.importDir, rel);
-            await mkdir10(path33.dirname(outFile), { recursive: true });
-            await writeFile13(outFile, buf);
+            const rel = path34.join("_salvaged", `${assetId}.png`);
+            const outFile = path34.resolve(ctx.importDir, rel);
+            await mkdir11(path34.dirname(outFile), { recursive: true });
+            await writeFile14(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -17785,7 +17907,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path33.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path34.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -17809,9 +17931,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log, characters: characterMembers });
-      const raw = JSON.parse(await readFile26(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile27(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await writeFile13(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile14(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       if (characterAssetIds.length) result.characterAssetIds = characterAssetIds;
       return result;