pixelkiln 0.72.0 → 0.74.0

package/dist/index.js

@@ -1001,7 +1001,7 @@ var AssetSchema = z.object({
       path: ["mirror"]
     });
   }
-  if (asset.prompt === void 0 && !asset.mirror && !asset.portrait && !asset.outfit) {
+  if (asset.prompt === void 0 && !asset.mirror && !asset.portrait && !asset.outfit && !asset.animation?.template) {
     context.addIssue({
       code: z.ZodIssueCode.custom,
       message: "Required",
@@ -1736,9 +1736,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path35, init) {
+  async request(path36, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path35}`, {
+    const res = await this.http(`${BASE}${path36}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -1748,13 +1748,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path35} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path36} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path35} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path36} returned invalid JSON`);
     }
   }
   async balance() {
@@ -2146,10 +2146,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 path35;
+    let path36;
     let body;
     if (args.mode === "v3") {
-      path35 = "/create-character-v3";
+      path36 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2163,7 +2163,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path35 = "/create-character-pro-flash";
+      path36 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -2187,7 +2187,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path35 = "/create-character-pro";
+      path36 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2201,7 +2201,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path35 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path36 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2218,8 +2218,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path35, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path35.slice(1));
+    const raw = await this.request(path36, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path36.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -3405,10 +3405,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path35) {
+async function sha256File(path36) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path35);
+    const stream = createReadStream(path36);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -3578,7 +3578,11 @@ function characterCost(spec) {
     return 20;
   }
   if (character.mode === "standard") return 1;
-  if (character.mode === "v3") return 1 + Math.max(1, Math.ceil(px * 8 / 65536));
+  if (character.mode === "v3") {
+    const south = character.reference?.south;
+    if (south) return Math.max(1, Math.ceil(south.width * south.height * 8 / 65536));
+    return 1 + Math.max(1, Math.ceil(px * 8 / 65536));
+  }
   if (character.mode === "pro-flash") {
     const south = character.reference?.south;
     return south ? proFlashCharacterCost(south.width, south.height, true) : proFlashCharacterCost(spec.width, spec.height, false);
@@ -5772,9 +5776,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(path35, init = {}) {
+  async call(path36, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path35}`, {
+    const response = await this.request(`${this.baseUrl}${path36}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -12063,10 +12067,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path35) {
-  if (!existsSync13(path35)) return { version: 1, hashes: {} };
+async function loadCache(path36) {
+  if (!existsSync13(path36)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path35, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile11(path36, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12078,18 +12082,18 @@ async function loadCache(path35) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path35, cache) {
+async function saveCache(path36, 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(path35)), { recursive: true });
-  const tmp = `${path35}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir5(pathModule.dirname(pathModule.resolve(path36)), { recursive: true });
+  const tmp = `${path36}.${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, path35);
+    await rename4(tmp, path36);
   } finally {
     await rm4(tmp, { force: true });
   }
@@ -14894,9 +14898,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { readFile as readFile22, stat as stat3 } from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 
 // src/workspace.ts
 import { mkdir as mkdir7, readFile as readFile18, rename as rename6, rm as rm7, writeFile as writeFile9 } from "fs/promises";
@@ -15032,8 +15036,8 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
-import path29 from "path";
-import { z as z11 } from "zod";
+import path30 from "path";
+import { z as z12 } from "zod";
 
 // src/manifest-edit.ts
 import { readFile as readFile19, rename as rename7, rm as rm8, writeFile as writeFile10 } from "fs/promises";
@@ -15064,13 +15068,16 @@ var NewAnimationSchema = z8.object({
   direction: CharacterDirectionSchema.optional(),
   frames: z8.number().int().min(4).max(16).optional(),
   fps: z8.number().int().min(1).max(60).optional(),
+  /** One loop per named direction, plus free mirrors; expanded when the manifest loads. */
+  directions: z8.array(CharacterDirectionSchema).min(1).optional(),
   mode: CharacterAnimationModeSchema.optional(),
   /** What is being animated, when the parent's own description would mislead the model (`character` only). */
   subject: z8.string().min(1).optional(),
   enhancePrompt: z8.boolean().optional()
 }).strict();
 var NewAssetSchema = z8.object({
-  prompt: z8.string(),
+  /** A portrait, an outfit, or a mirror has none of its own; the loader says where one is needed. */
+  prompt: z8.string().optional(),
   category: z8.string().optional(),
   width: z8.number().int().optional(),
   height: z8.number().int().optional(),
@@ -15105,7 +15112,24 @@ var NewAssetSchema = z8.object({
   /** 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. */
-  animation: NewAnimationSchema.optional()
+  animation: NewAnimationSchema.optional(),
+  /** A bust of an existing character. */
+  portrait: CharacterPortraitSchema.optional(),
+  /** An existing loop re-clothed from a reference image (uploaded first). */
+  outfit: CharacterOutfitSchema.optional(),
+  /** Another asset of the same style, flipped; free. */
+  mirror: z8.string().min(1).optional(),
+  /**
+   * `character`/`objectPro` bases: the subject's own sprite (uploaded
+   * first), or one per direction, which PixelLab rotates instead of drawing.
+   */
+  reference: z8.union([z8.string().min(1), z8.record(CharacterDirectionSchema, z8.string().min(1))]).optional(),
+  /** `character` pro bases: a concept image that seeds the design. */
+  concept: z8.string().min(1).optional(),
+  /** `character` pro bases: another character in the style whose look this one follows. */
+  styleCharacter: z8.string().min(1).optional(),
+  /** `character` standard humanoid bases: this character's proportions, over the style's. */
+  proportions: CharacterProportionsSchema.optional()
 }).strict().refine((asset) => !(asset.revision && (asset.state || asset.animation)), {
   message: "an asset is a revision, a state, or an animation \u2014 not more than one"
 }).refine((asset) => !(asset.state && asset.animation), {
@@ -15116,59 +15140,95 @@ var CANDIDATE_OPTION = {
   comfyui: "numImages",
   scenario: "numOutputs"
 };
+var NewStyleSchema = z8.object({
+  generator: z8.enum(["character", "objectPro"]),
+  /** Where the style's art is written, inside the project. */
+  outDir: z8.string().min(1).refine((dir) => !dir.split(/[\\/]/).includes("..") && !/^([a-z]:)?[\\/]/i.test(dir), {
+    message: "outDir must be a path inside the project"
+  }),
+  size: z8.number().int().min(16).max(256).optional(),
+  mode: CharacterModeSchema.optional(),
+  directions: z8.union([z8.literal(4), z8.literal(8)]).optional(),
+  template: z8.string().min(1).optional(),
+  view: z8.string().min(1).max(64).optional(),
+  proportions: CharacterProportionsSchema.optional(),
+  isometric: z8.boolean().optional(),
+  textGuidanceScale: z8.number().min(1).max(20).optional(),
+  enhancePrompt: z8.boolean().optional(),
+  promptPrefix: z8.string().optional(),
+  promptSuffix: z8.string().optional(),
+  palette: z8.array(z8.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).optional()
+}).strict();
+var PatchAssetEdit = z8.object({
+  action: z8.literal("patch-asset"),
+  assetId: z8.string().min(1),
+  patch: AssetPatchSchema
+}).strict();
+var AddAssetEdit = z8.object({
+  action: z8.literal("add-asset"),
+  assetId: z8.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  asset: NewAssetSchema
+}).strict();
+var SetSourceEdit = z8.object({
+  action: z8.literal("set-source"),
+  assetId: z8.string().min(1),
+  styleId: z8.string().min(1),
+  /** Manifest-relative path of the art that stands in for this asset in this style. */
+  source: z8.string().min(1)
+}).strict();
+var ClearSourceEdit = z8.object({
+  action: z8.literal("clear-source"),
+  assetId: z8.string().min(1),
+  styleId: z8.string().min(1)
+}).strict();
+var PatchStyleEdit = z8.object({
+  action: z8.literal("patch-style"),
+  styleId: z8.string().min(1),
+  patch: z8.object({
+    /** Candidates per generation, written to the provider's own option. */
+    candidates: z8.number().int().min(1).max(64).optional(),
+    /** Empty clears the style's own value (inherit, or the default). */
+    promptPrefix: z8.string().optional(),
+    promptSuffix: z8.string().optional(),
+    /** `#rrggbb` values; null or empty clears the style's own palette. */
+    palette: z8.array(z8.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).nullable().optional(),
+    /** Snap downloaded art to the palette; false clears the style's own value. */
+    enforcePalette: z8.boolean().optional(),
+    /** Provider view name (PixelLab: low top-down, high top-down, side); empty clears. */
+    view: z8.string().max(64).nullable().optional(),
+    /** pixflux only; null clears the style's own value. */
+    noBackground: z8.boolean().nullable().optional()
+  }).strict().refine((patch) => Object.keys(patch).length > 0, { message: "nothing to change" })
+}).strict();
+var AddStyleEdit = z8.object({
+  action: z8.literal("add-style"),
+  styleId: z8.string().min(1).regex(/^[^/\\:]+$/, "style ids cannot contain slashes or colons"),
+  style: NewStyleSchema
+}).strict();
+var Envelope = {
+  /** Workspace project id; omitted for a single-project gallery. */
+  project: z8.string().min(1).optional(),
+  /** Manifest bytes the page last saw; a mismatch refuses the write. */
+  expectedSha256: HexSha
+};
+var SingleEdit = z8.discriminatedUnion("action", [PatchAssetEdit, AddAssetEdit, SetSourceEdit, ClearSourceEdit, PatchStyleEdit, AddStyleEdit]);
 var ManifestEditSchema = z8.discriminatedUnion("action", [
+  PatchAssetEdit.extend(Envelope),
+  AddAssetEdit.extend(Envelope),
+  SetSourceEdit.extend(Envelope),
+  ClearSourceEdit.extend(Envelope),
+  PatchStyleEdit.extend(Envelope),
+  AddStyleEdit.extend(Envelope),
+  /**
+   * Several edits as one write: a new character's style, base, and loops
+   * land together or not at all, validated once as the finished manifest.
+   * Each edit sees the ones before it, so a base can name a style the same
+   * batch adds.
+   */
   z8.object({
-    action: z8.literal("patch-asset"),
-    /** Workspace project id; omitted for a single-project gallery. */
-    project: z8.string().min(1).optional(),
-    assetId: z8.string().min(1),
-    /** Manifest bytes the page last saw; a mismatch refuses the write. */
-    expectedSha256: HexSha,
-    patch: AssetPatchSchema
-  }).strict(),
-  z8.object({
-    action: z8.literal("add-asset"),
-    project: z8.string().min(1).optional(),
-    assetId: z8.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
-    expectedSha256: HexSha,
-    asset: NewAssetSchema
-  }).strict(),
-  z8.object({
-    action: z8.literal("set-source"),
-    project: z8.string().min(1).optional(),
-    assetId: z8.string().min(1),
-    styleId: z8.string().min(1),
-    /** Manifest-relative path of the art that stands in for this asset in this style. */
-    source: z8.string().min(1),
-    expectedSha256: HexSha
-  }).strict(),
-  z8.object({
-    action: z8.literal("clear-source"),
-    project: z8.string().min(1).optional(),
-    assetId: z8.string().min(1),
-    styleId: z8.string().min(1),
-    expectedSha256: HexSha
-  }).strict(),
-  z8.object({
-    action: z8.literal("patch-style"),
-    project: z8.string().min(1).optional(),
-    styleId: z8.string().min(1),
-    expectedSha256: HexSha,
-    patch: z8.object({
-      /** Candidates per generation, written to the provider's own option. */
-      candidates: z8.number().int().min(1).max(64).optional(),
-      /** Empty clears the style's own value (inherit, or the default). */
-      promptPrefix: z8.string().optional(),
-      promptSuffix: z8.string().optional(),
-      /** `#rrggbb` values; null or empty clears the style's own palette. */
-      palette: z8.array(z8.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).nullable().optional(),
-      /** Snap downloaded art to the palette; false clears the style's own value. */
-      enforcePalette: z8.boolean().optional(),
-      /** Provider view name (PixelLab: low top-down, high top-down, side); empty clears. */
-      view: z8.string().max(64).nullable().optional(),
-      /** pixflux only; null clears the style's own value. */
-      noBackground: z8.boolean().nullable().optional()
-    }).strict().refine((patch) => Object.keys(patch).length > 0, { message: "nothing to change" })
+    action: z8.literal("batch"),
+    ...Envelope,
+    edits: z8.array(SingleEdit).min(1).max(64)
   }).strict()
 ]);
 var ManifestDriftError = class extends Error {
@@ -15217,6 +15277,18 @@ function undeclaredAsset(raw, assetId) {
 }
 function applyEdit(raw, edit) {
   raw.assets ??= {};
+  if (edit.action === "batch") {
+    for (const each of edit.edits) applyEdit(raw, each);
+    return;
+  }
+  if (edit.action === "add-style") {
+    raw.styles ??= {};
+    if (Object.hasOwn(raw.styles, edit.styleId)) throw new ManifestEditError(`style "${edit.styleId}" already exists`);
+    const style = { ...edit.style };
+    if (edit.style.palette) style.palette = edit.style.palette.map((color) => "#" + color.replace(/^#/, "").toLowerCase());
+    raw.styles[edit.styleId] = style;
+    return;
+  }
   if (edit.action === "set-source" || edit.action === "clear-source") {
     const asset2 = Object.hasOwn(raw.assets, edit.assetId) ? raw.assets[edit.assetId] : void 0;
     if (!asset2) throw undeclaredAsset(raw, edit.assetId);
@@ -15294,6 +15366,15 @@ function applyEdit(raw, edit) {
     if (edit.asset.animation && !declaredAssets(raw).has(edit.asset.animation.of)) {
       throw new ManifestEditError(`animation parent "${edit.asset.animation.of}" is not declared by the manifest`);
     }
+    for (const [what, parent] of [
+      ["portrait", edit.asset.portrait?.of],
+      ["outfit", edit.asset.outfit?.of],
+      ["mirror", edit.asset.mirror]
+    ]) {
+      if (parent && !declaredAssets(raw).has(parent)) {
+        throw new ManifestEditError(`${what} source "${parent}" is not declared by the manifest`);
+      }
+    }
     raw.assets[edit.assetId] = asset2;
     return;
   }
@@ -15321,11 +15402,10 @@ function applyEdit(raw, edit) {
     else delete asset.tags;
   }
 }
-async function applyManifestEdit(manifestPath, edit) {
+async function withCandidate(manifestPath, edit, use, unchanged) {
   const absolute = path26.resolve(manifestPath);
   const original = await readFile19(absolute, "utf8");
-  const before = sha256(original);
-  if (before !== edit.expectedSha256) throw new ManifestDriftError(absolute);
+  if (sha256(original) !== edit.expectedSha256) throw new ManifestDriftError(absolute);
   let raw;
   try {
     raw = JSON.parse(original);
@@ -15336,25 +15416,35 @@ async function applyManifestEdit(manifestPath, edit) {
   }
   applyEdit(raw, edit);
   const next = serializeLike(original, raw);
-  if (next === original) return { manifestPath: absolute, sha256: before, changed: false };
+  if (next === original) return unchanged(absolute, original);
   const tmp = path26.join(
     path26.dirname(absolute),
     `.${path26.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
   );
   try {
     await writeFile10(tmp, next);
+    let specs;
     try {
-      const loaded = await loadManifest(tmp);
-      await resolveSpecs(loaded);
+      specs = await resolveSpecs(await loadManifest(tmp));
     } catch (error) {
       const message6 = error instanceof Error ? error.message : String(error);
       throw new ManifestEditError(message6.replace(tmp, absolute));
     }
-    await rename7(tmp, absolute);
+    return await use({ absolute, original, next, tmp, specs });
   } finally {
     await rm8(tmp, { force: true });
   }
-  return { manifestPath: absolute, sha256: sha256(next), changed: true };
+}
+async function applyManifestEdit(manifestPath, edit) {
+  return withCandidate(
+    manifestPath,
+    edit,
+    async ({ absolute, next, tmp }) => {
+      await rename7(tmp, absolute);
+      return { manifestPath: absolute, sha256: sha256(next), changed: true };
+    },
+    (absolute, original) => ({ manifestPath: absolute, sha256: sha256(original), changed: false })
+  );
 }
 
 // src/pipeline/hand-edit.ts
@@ -15605,62 +15695,103 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
   return openExternal(file, command);
 }
 
-// src/gallery/skeleton.ts
+// src/gallery/upload.ts
 import { existsSync as existsSync23 } from "fs";
-import { mkdir as mkdir9, readFile as readFile21, rm as rm10, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir9, writeFile as writeFile12 } from "fs/promises";
 import path28 from "path";
 import { z as z10 } from "zod";
-var SkeletonEstimateRequestSchema = z10.object({
+var MAX_UPLOAD_BYTES = 8 * 1024 * 1024;
+var UploadImageSchema = z10.object({
+  action: z10.literal("upload-image"),
   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()
+  /** Manifest-relative destination, ending .png, .jpg, or .jpeg. */
+  path: z10.string().min(1),
+  base64: z10.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_UPLOAD_BYTES / 3) * 4),
+  /** Replace a file already at `path`. */
+  overwrite: z10.boolean().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),
+async function saveProjectImage(root, request) {
+  const file = path28.resolve(root, request.path);
+  const relative = path28.relative(root, file);
+  if (relative.startsWith("..") || path28.isAbsolute(relative)) {
+    throw new ManifestEditError("an upload must stay inside the project");
+  }
+  const extension = path28.extname(file).toLowerCase();
+  const expected = extension === ".png" ? "png" : extension === ".jpg" || extension === ".jpeg" ? "jpeg" : null;
+  if (!expected) throw new ManifestEditError("an upload must be a .png, .jpg, or .jpeg path");
+  const bytes = Buffer.from(request.base64, "base64");
+  if (!bytes.length || bytes.length > MAX_UPLOAD_BYTES) {
+    throw new ManifestEditError(`an upload must be between 1 byte and ${MAX_UPLOAD_BYTES / 1024 / 1024} MB`);
+  }
+  const metadata = imageMetadata(bytes);
+  if (!metadata) throw new ManifestEditError("the upload is not a readable PNG or JPEG");
+  if (metadata.format !== expected) {
+    throw new ManifestEditError(`the upload is a ${metadata.format.toUpperCase()}; name it ${metadata.format === "png" ? ".png" : ".jpg"}`);
+  }
+  if (existsSync23(file) && !request.overwrite) {
+    throw new ManifestEditError(`${relative.split(path28.sep).join("/")} already exists; choose another name, or replace it`);
+  }
+  await mkdir9(path28.dirname(file), { recursive: true });
+  await writeFile12(file, bytes);
+  return relative.split(path28.sep).join("/");
+}
+
+// src/gallery/skeleton.ts
+import { existsSync as existsSync24 } from "fs";
+import { mkdir as mkdir10, readFile as readFile21, rm as rm10, writeFile as writeFile13 } from "fs/promises";
+import path29 from "path";
+import { z as z11 } from "zod";
+var SkeletonEstimateRequestSchema = z11.object({
+  project: z11.string().min(1).optional(),
+  styleId: z11.string().min(1),
+  assetId: z11.string().min(1),
+  frames: z11.number().int().min(3).max(15).optional()
+}).strict();
+var SkeletonAnimationRequestSchema = z11.object({
+  action: z11.literal("create-skeleton-animation"),
+  project: z11.string().min(1).optional(),
+  expectedSha256: z11.string().regex(/^[0-9a-f]{64}$/),
+  styleId: z11.string().min(1),
   /** The sprite the animation poses. */
-  from: z10.string().min(1),
-  assetId: z10.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  from: z11.string().min(1),
+  assetId: z11.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
   /** The motion, sent as PixelLab's `action`. */
-  prompt: z10.string().min(1),
+  prompt: z11.string().min(1),
   direction: CharacterDirectionSchema,
-  description: z10.string().min(1).optional(),
-  skeletonTemplate: z10.string().min(1).optional(),
+  description: z11.string().min(1).optional(),
+  skeletonTemplate: z11.string().min(1).optional(),
   /** Manifest-relative JSON path inside the project. */
-  keypointsFile: z10.string().min(1),
+  keypointsFile: z11.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()
+  overwrite: z11.boolean().optional()
 }).strict();
-var SkeletonKeypointsUpdateSchema = z10.object({
-  action: z10.literal("update-skeleton-keypoints"),
-  project: z10.string().min(1).optional(),
-  styleId: z10.string().min(1),
-  assetId: z10.string().min(1),
+var SkeletonKeypointsUpdateSchema = z11.object({
+  action: z11.literal("update-skeleton-keypoints"),
+  project: z11.string().min(1).optional(),
+  styleId: z11.string().min(1),
+  assetId: z11.string().min(1),
   /** The file's SHA-256 when the page loaded it; anything else on disk is a concurrent edit. */
-  expectedSha256: z10.string().regex(/^[0-9a-f]{64}$/),
+  expectedSha256: z11.string().regex(/^[0-9a-f]{64}$/),
   set: SkeletonSetSchema
 }).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)) {
+  const root = path29.dirname(path29.resolve(manifestPath));
+  const file = path29.resolve(root, request.keypointsFile);
+  const relative = path29.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || path29.isAbsolute(relative)) {
     throw new ManifestEditError("the keypoints file must be a .json path inside the project");
   }
-  const existed = existsSync23(file);
+  const existed = existsSync24(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");
+    await mkdir10(path29.dirname(file), { recursive: true });
+    await writeFile13(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`);
   }
@@ -15675,7 +15806,7 @@ async function createSkeletonAnimation(manifestPath, request) {
         revision: {
           mode: "animate-skeleton",
           from: request.from,
-          keypointsFile: relative.split(path28.sep).join("/"),
+          keypointsFile: relative.split(path29.sep).join("/"),
           direction: request.direction,
           ...request.description ? { description: request.description } : {},
           ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
@@ -15684,7 +15815,7 @@ async function createSkeletonAnimation(manifestPath, request) {
     });
   } catch (error) {
     if (request.set) {
-      if (previous) await writeFile12(file, previous);
+      if (previous) await writeFile13(file, previous);
       else await rm10(file, { force: true });
     }
     throw error;
@@ -15696,56 +15827,56 @@ async function updateSkeletonKeypoints(ctx, request) {
   if (!spec) throw new ManifestEditError(`"${key}" is not declared by the manifest`);
   const file = spec.revision?.mode === "animate-skeleton" ? spec.revision.keypointsFile : void 0;
   if (!file) throw new ManifestEditError(`${key} is not an animate-skeleton revision`);
-  const relative = path28.relative(ctx.loaded.root, file);
-  if (relative.startsWith("..") || path28.isAbsolute(relative)) {
+  const relative = path29.relative(ctx.loaded.root, file);
+  if (relative.startsWith("..") || path29.isAbsolute(relative)) {
     throw new ManifestEditError(`${key}'s keypoints file is outside the project; edit it by hand`);
   }
-  const current = existsSync23(file) ? sha256(await readFile21(file)) : null;
+  const current = existsSync24(file) ? sha256(await readFile21(file)) : null;
   if (current !== request.expectedSha256) {
     throw Object.assign(
-      new Error(`${relative.split(path28.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
+      new Error(`${relative.split(path29.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
       { status: 409 }
     );
   }
-  await writeFile12(file, JSON.stringify(request.set, null, 2) + "\n");
-  return relative.split(path28.sep).join("/");
+  await writeFile13(file, JSON.stringify(request.set, null, 2) + "\n");
+  return relative.split(path29.sep).join("/");
 }
 
 // src/gallery/edit.ts
-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}$/),
+var Base64 = z12.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = z12.discriminatedUnion("action", [
+  z12.object({
+    action: z12.literal("start-edit"),
+    project: z12.string().min(1).optional(),
+    assetId: z12.string().min(1),
+    styleId: z12.string().min(1),
+    expectedSha256: z12.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: z11.boolean().optional()
+    open: z12.boolean().optional()
   }).strict(),
-  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}$/)
+  z12.object({
+    action: z12.literal("detach-edit"),
+    project: z12.string().min(1).optional(),
+    assetId: z12.string().min(1),
+    styleId: z12.string().min(1),
+    expectedSha256: z12.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  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}$/),
+  z12.object({
+    action: z12.literal("save-edit"),
+    project: z12.string().min(1).optional(),
+    assetId: z12.string().min(1),
+    styleId: z12.string().min(1),
+    expectedSha256: z12.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: z11.array(z11.object({ role: z11.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: z12.array(z12.object({ role: z12.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: z11.string().min(1).max(200),
-    protocol: z11.number().int().positive()
+    editor: z12.string().min(1).max(200),
+    protocol: z12.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -15786,6 +15917,21 @@ function createGalleryEditHandler(opts) {
       }
       return opts.reload();
     }
+    const upload = UploadImageSchema.safeParse(body);
+    if (upload.success) {
+      let manifestPath2;
+      try {
+        manifestPath2 = await opts.manifestFor(upload.data.project);
+      } catch (error) {
+        throw new ManifestEditError(error instanceof Error ? error.message : String(error));
+      }
+      const written = await saveProjectImage(path30.dirname(path30.resolve(manifestPath2)), upload.data);
+      log(`  image added: ${written}`);
+      return opts.reload();
+    }
+    if (body?.action === "upload-image") {
+      throw new ManifestEditError("invalid upload: " + upload.error.issues.slice(0, 2).map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; "));
+    }
     const poses = SkeletonKeypointsUpdateSchema.safeParse(body);
     if (poses.success) {
       if (!opts.loadProject) throw new ManifestEditError("pose edits are not available in this gallery");
@@ -15829,19 +15975,35 @@ function createGalleryEditHandler(opts) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = path29.relative(process.cwd(), result.manifestPath);
+      const relative = path30.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}`);
+      log(`  manifest edited: ${describeEdit(parsed.data)} in ${shown}`);
     }
     return opts.reload();
   };
 }
+function describeEdit(edit) {
+  switch (edit.action) {
+    case "batch":
+      return `${edit.edits.length} changes (${edit.edits.map(describeEdit).join("; ")})`;
+    case "add-style":
+      return `added style ${edit.styleId}`;
+    case "patch-style":
+      return `changed style ${edit.styleId}`;
+    case "set-source":
+    case "clear-source":
+      return `changed ${edit.styleId}/${edit.assetId} source`;
+    case "add-asset":
+      return `added ${edit.assetId}`;
+    case "patch-asset":
+      return `changed ${edit.assetId}`;
+  }
+}
 
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return createHash4("sha256").update(path30.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return createHash4("sha256").update(path31.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -15860,9 +16022,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 = path30.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = path31.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if (existsSync24(file)) {
+      if (existsSync25(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -15992,10 +16154,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, path30.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, path31.resolve(root, file)))
   );
-  const recordPath = path30.resolve(root, inspection.record);
-  const recordExists = existsSync24(recordPath);
+  const recordPath = path31.resolve(root, inspection.record);
+  const recordExists = existsSync25(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -16014,7 +16176,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path30.resolve(root, inspection.output), root),
+    output: portableOutputPath(path31.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -16054,7 +16216,7 @@ async function buildGallerySnapshot(opts) {
   const items = [];
   const manifestText = await readFile22(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = path30.resolve(path30.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = path31.resolve(path31.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -16078,12 +16240,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path30.resolve(root, spec.source);
+        const editPath = path31.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: existsSync24(file) ? await sha256File(file) : null };
+            return { file, sha256: existsSync25(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -16091,7 +16253,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && existsSync24(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && existsSync25(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -16127,8 +16289,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, path30.resolve(root, spec.source))];
-    } else if (!entry && existsSync24(spec.outFile)) {
+      outputs = [await describeOutput(media, root, path31.resolve(root, spec.source))];
+    } else if (!entry && existsSync25(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -16329,7 +16491,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path30.resolve(opts.lockPath),
+      lock: path31.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -16355,7 +16517,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path30.dirname(path30.resolve(opts.workspacePath));
+  const dir = path31.dirname(path31.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -16398,7 +16560,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path30.resolve(lockPath),
+        lock: path31.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
@@ -16414,8 +16576,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path30.resolve(lockPath),
-        root: path30.dirname(manifestPath),
+        lock: path31.resolve(lockPath),
+        root: path31.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -16442,7 +16604,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: path30.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: path31.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -16459,7 +16621,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 
 // src/gallery/page.ts
-import { existsSync as existsSync25, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync5 } from "fs";
 
 // src/gallery/client-bundle.ts
 import { createRequire } from "module";
@@ -16500,7 +16662,7 @@ function clientAssets() {
   const prebuilt = new URL("gallery.js", CLIENT_DIR);
   client ??= {
     css: readFileSync5(new URL("gallery.css", CLIENT_DIR), "utf8"),
-    js: existsSync25(prebuilt) ? readFileSync5(prebuilt, "utf8") : bundleGalleryClient()
+    js: existsSync26(prebuilt) ? readFileSync5(prebuilt, "utf8") : bundleGalleryClient()
   };
   return client;
 }
@@ -16542,6 +16704,7 @@ ${css}</style>
       <option value="none">Group: none</option>
     </select>
     <span id="editing" class="editing" hidden title="This gallery can write the manifest. It never contacts a provider.">editing</span>
+    <button id="studio" type="button" hidden title="Draft a new character: its style, base, loops, and portrait, priced as you go">+ New character</button>
     <button id="refresh" type="button" title="Re-read the manifest, lockfile, and disk">Refresh</button>
     <label class="chip" title="Refresh every 5 seconds while this tab is visible"><input id="auto" type="checkbox"> auto</label>
   </div>
@@ -16627,10 +16790,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 existsSync26 } 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 { 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 os2 from "os";
-import path31 from "path";
+import path32 from "path";
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -16641,15 +16804,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return path31.resolve(override);
-  if (process.platform === "darwin") return path31.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return path32.resolve(override);
+  if (process.platform === "darwin") return path32.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return path31.join(process.env.LOCALAPPDATA ?? path31.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return path32.join(process.env.LOCALAPPDATA ?? path32.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return path31.join(process.env.XDG_CACHE_HOME ?? path31.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
+  return path32.join(process.env.XDG_CACHE_HOME ?? path32.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return path31.join(root, "pixelorama", pin.release ?? "unpublished");
+  return path32.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -16672,8 +16835,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = path31.join(dir, name);
-    const info = existsSync26(file) ? await stat4(file).catch(() => null) : null;
+    const file = path32.join(dir, name);
+    const info = existsSync27(file) ? await stat4(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -16702,7 +16865,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await mkdir10(dir, { recursive: true });
+  await mkdir11(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -16730,10 +16893,10 @@ 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 = path31.join(dir, name);
+    const final = path32.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await writeFile13(tmp, bytes);
+      await writeFile14(tmp, bytes);
       await rename9(tmp, final);
     } finally {
       await rm11(tmp, { force: true });
@@ -16776,12 +16939,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[path31.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[path32.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
 import { readFile as readFile24 } from "fs/promises";
-import path32 from "path";
+import path33 from "path";
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -16854,7 +17017,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile24(path32.join(dir, name));
+        bytes = await readFile24(path33.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -16899,7 +17062,7 @@ async function readJsonBody(req) {
 async function serveGallery(opts) {
   const log = opts.onProgress ?? (() => {
   });
-  const session = opts.edit || opts.generate || opts.editor || opts.skeleton ? randomBytes(16).toString("hex") : null;
+  const session = opts.edit || opts.generate || opts.editor || opts.skeleton || opts.price ? randomBytes(16).toString("hex") : null;
   let media = /* @__PURE__ */ new Map();
   let loading = null;
   const reviewAssets = /* @__PURE__ */ new Map();
@@ -16974,6 +17137,17 @@ async function serveGallery(opts) {
       }
       return;
     }
+    if (req.method === "POST" && url2.pathname === "/api/price") {
+      if (!opts.price || !session) return fail(405, "pricing an edit needs the gallery started with --edit");
+      try {
+        const body = await guardedBody("price requests");
+        if (body === void 0) return;
+        json(200, await opts.price(body));
+      } catch (err) {
+        reportError("price", err);
+      }
+      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 {
@@ -17168,27 +17342,27 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 import { randomBytes as randomBytes2 } from "crypto";
-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),
+import { z as z13 } from "zod";
+var GenerateRequestSchema = z13.object({
+  project: z13.string().min(1).optional(),
+  keys: z13.array(z13.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: z12.boolean().optional(),
+  force: z13.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: z12.boolean().optional(),
+  resume: z13.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: z12.boolean().optional(),
+  refresh: z13.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: z12.boolean().optional(),
+  restore: z13.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: z12.string().min(1).max(64).optional()
+  revert: z13.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" });
@@ -17312,6 +17486,70 @@ function createGenerateHandlers(opts) {
     job.phase = "done";
     job.finishedAt = now().toISOString();
   }
+  async function submitGroups(job, ctx, groups) {
+    job.phase = "submitting";
+    for (const group of groups) {
+      const provider = opts.providerFor(job.project ?? void 0, group.provider);
+      const ceiling = remainingFor(group, groups.length, opts.budget, spent);
+      if (provider.balance) {
+        const balance = await provider.balance();
+        say(job, `balance: ${formatCost(balance.unit, balance.remaining)} remaining (${group.provider})`);
+        if (balance.unit !== group.costUnit) {
+          throw new Error(
+            `Provider ${group.provider} estimate unit ${group.costUnit} does not match balance unit ${balance.unit}.`
+          );
+        }
+        if (balance.unit !== "free" && group.cost > balance.remaining) {
+          throw new Error(
+            `${group.provider} needs ${formatCost(balance.unit, group.cost)} but only ${formatCost(balance.unit, balance.remaining)} remain.`
+          );
+        }
+      }
+      const res = await submit(provider, ctx.loaded, group.actionable, ctx.lock, ctx.lockPath, {
+        budget: ceiling,
+        onProgress: (line) => say(job, line),
+        spacingMs: opts.submitSpacingMs
+      });
+      spent[group.provider] = (spent[group.provider] ?? 0) + res.spent;
+      units[group.provider] = res.unit;
+      job.spent[group.provider] = (job.spent[group.provider] ?? 0) + res.spent;
+      job.counts.submitted += res.submitted;
+      job.counts.failed += res.failed;
+      say(job, `${group.provider}: submitted ${res.submitted}, failed ${res.failed}, estimated ${formatCost(res.unit, res.spent)}`);
+    }
+  }
+  async function generateInWaves(job, ctx, specs, groups) {
+    for (let wave = 1; ; wave++) {
+      const submittedBefore = job.counts.submitted;
+      await submitGroups(job, ctx, groups);
+      await settle(job, ctx, specs);
+      if (job.phase !== "done" || job.counts.submitted === submittedBefore) return;
+      const finishedAt = job.finishedAt;
+      const finish = () => {
+        job.phase = "done";
+        job.finishedAt = finishedAt;
+      };
+      job.phase = "queued";
+      job.finishedAt = null;
+      const next = await opts.loadProject(job.project ?? void 0);
+      const byKey = new Map(next.specs.map((spec) => [lockKey(spec.styleId, spec.assetId), spec]));
+      const nextSpecs = job.keys.map((key) => byKey.get(key)).filter((spec) => Boolean(spec));
+      const plan = await buildPlan(nextSpecs, next.lock);
+      if (!plan.actionable.length) return finish();
+      for (const group of plan.groups) {
+        const remaining = remainingFor(group, plan.groups.length, opts.budget, spent);
+        if (group.cost > remaining) {
+          say(job, `wave ${wave + 1} would spend ${formatCost(group.costUnit, group.cost)} on ${group.provider} but only ${formatCost(group.costUnit, remaining)} of this session's budget remain; stopping here`);
+          return finish();
+        }
+      }
+      say(job, `wave ${wave + 1}: ${plan.actionable.length} asset(s) whose parents are now on disk: ` + plan.groups.map((g) => `${g.provider} ${formatCost(g.costUnit, g.cost)}`).join("; "));
+      contexts.set(job.id, next);
+      ctx = next;
+      specs = nextSpecs;
+      groups = plan.groups;
+    }
+  }
   async function run(job, ctx, specs, groups) {
     try {
       if (job.mode === "refresh") {
@@ -17339,36 +17577,8 @@ function createGenerateHandlers(opts) {
         return;
       }
       if (job.mode === "generate") {
-        job.phase = "submitting";
-        for (const group of groups) {
-          const provider = opts.providerFor(job.project ?? void 0, group.provider);
-          const ceiling = remainingFor(group, groups.length, opts.budget, spent);
-          if (provider.balance) {
-            const balance = await provider.balance();
-            say(job, `balance: ${formatCost(balance.unit, balance.remaining)} remaining (${group.provider})`);
-            if (balance.unit !== group.costUnit) {
-              throw new Error(
-                `Provider ${group.provider} estimate unit ${group.costUnit} does not match balance unit ${balance.unit}.`
-              );
-            }
-            if (balance.unit !== "free" && group.cost > balance.remaining) {
-              throw new Error(
-                `${group.provider} needs ${formatCost(balance.unit, group.cost)} but only ${formatCost(balance.unit, balance.remaining)} remain.`
-              );
-            }
-          }
-          const res = await submit(provider, ctx.loaded, group.actionable, ctx.lock, ctx.lockPath, {
-            budget: ceiling,
-            onProgress: (line) => say(job, line),
-            spacingMs: opts.submitSpacingMs
-          });
-          spent[group.provider] = (spent[group.provider] ?? 0) + res.spent;
-          units[group.provider] = res.unit;
-          job.spent[group.provider] = (job.spent[group.provider] ?? 0) + res.spent;
-          job.counts.submitted += res.submitted;
-          job.counts.failed += res.failed;
-          say(job, `${group.provider}: submitted ${res.submitted}, failed ${res.failed}, estimated ${formatCost(res.unit, res.spent)}`);
-        }
+        await generateInWaves(job, ctx, specs, groups);
+        return;
       }
       await settle(job, ctx, specs);
     } catch (error) {
@@ -17499,15 +17709,15 @@ function createGenerateHandlers(opts) {
 
 // src/pipeline/salvage.ts
 import { readFile as readFile26 } from "fs/promises";
-import { existsSync as existsSync27 } from "fs";
-import path33 from "path";
+import { existsSync as existsSync28 } from "fs";
+import path34 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 (!existsSync27(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!existsSync28(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
       parsed = parseLock(JSON.parse(await readFile26(p, "utf8")));
@@ -17614,20 +17824,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path33.resolve(ownManifestPath);
+  const own = path34.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path33.join(path33.dirname(path33.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path34.join(path34.dirname(path34.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path33.resolve(siblingManifestPath) === own) continue;
-    if (!existsSync27(siblingManifestPath)) continue;
+    if (path34.resolve(siblingManifestPath) === own) continue;
+    if (!existsSync28(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path33.basename(path33.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path34.basename(path34.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -17747,8 +17957,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir11, writeFile as writeFile14, readFile as readFile27 } from "fs/promises";
-import path34 from "path";
+import { mkdir as mkdir12, writeFile as writeFile15, readFile as readFile27 } from "fs/promises";
+import path35 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -17914,7 +18124,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path34.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path35.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]));
@@ -17970,10 +18180,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 = path34.join("_salvaged", `${assetId}.png`);
-            const outFile = path34.resolve(ctx.importDir, rel);
-            await mkdir11(path34.dirname(outFile), { recursive: true });
-            await writeFile14(outFile, buf);
+            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);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -18005,7 +18215,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path34.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path35.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -18031,7 +18241,7 @@ 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"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await writeFile14(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile15(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       if (characterAssetIds.length) result.characterAssetIds = characterAssetIds;
       return result;