pixelkiln 0.72.0 → 0.74.0

package/dist/index.cjs

@@ -1325,7 +1325,7 @@ var AssetSchema = import_zod.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: import_zod.z.ZodIssueCode.custom,
       message: "Required",
@@ -2060,9 +2060,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,
@@ -2072,13 +2072,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() {
@@ -2470,10 +2470,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,
@@ -2487,7 +2487,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,
@@ -2511,7 +2511,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path35 = "/create-character-pro";
+      path36 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2525,7 +2525,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,
@@ -2542,8 +2542,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) {
@@ -3729,10 +3729,10 @@ var import_node_fs = require("fs");
 function sha256(data) {
   return (0, import_node_crypto.createHash)("sha256").update(data).digest("hex");
 }
-async function sha256File(path35) {
+async function sha256File(path36) {
   return new Promise((resolve, reject) => {
     const hash = (0, import_node_crypto.createHash)("sha256");
-    const stream = (0, import_node_fs.createReadStream)(path35);
+    const stream = (0, import_node_fs.createReadStream)(path36);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -3902,7 +3902,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);
@@ -6096,9 +6100,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",
@@ -12387,10 +12391,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path35) {
-  if (!(0, import_node_fs14.existsSync)(path35)) return { version: 1, hashes: {} };
+async function loadCache(path36) {
+  if (!(0, import_node_fs14.existsSync)(path36)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises11.readFile)(path35, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises11.readFile)(path36, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12402,18 +12406,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 (0, import_promises11.mkdir)(import_node_path18.default.dirname(import_node_path18.default.resolve(path35)), { recursive: true });
-  const tmp = `${path35}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await (0, import_promises11.mkdir)(import_node_path18.default.dirname(import_node_path18.default.resolve(path36)), { recursive: true });
+  const tmp = `${path36}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await (0, import_promises11.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await (0, import_promises11.rename)(tmp, path35);
+    await (0, import_promises11.rename)(tmp, path36);
   } finally {
     await (0, import_promises11.rm)(tmp, { force: true });
   }
@@ -15218,9 +15222,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 var import_node_crypto6 = require("crypto");
-var import_node_fs26 = require("fs");
-var import_promises23 = require("fs/promises");
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_fs27 = require("fs");
+var import_promises24 = require("fs/promises");
+var import_node_path32 = __toESM(require("path"), 1);
 
 // src/workspace.ts
 var import_promises19 = require("fs/promises");
@@ -15356,8 +15360,8 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
-var import_node_path30 = __toESM(require("path"), 1);
-var import_zod11 = require("zod");
+var import_node_path31 = __toESM(require("path"), 1);
+var import_zod12 = require("zod");
 
 // src/manifest-edit.ts
 var import_promises20 = require("fs/promises");
@@ -15388,13 +15392,16 @@ var NewAnimationSchema = import_zod8.z.object({
   direction: CharacterDirectionSchema.optional(),
   frames: import_zod8.z.number().int().min(4).max(16).optional(),
   fps: import_zod8.z.number().int().min(1).max(60).optional(),
+  /** One loop per named direction, plus free mirrors; expanded when the manifest loads. */
+  directions: import_zod8.z.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: import_zod8.z.string().min(1).optional(),
   enhancePrompt: import_zod8.z.boolean().optional()
 }).strict();
 var NewAssetSchema = import_zod8.z.object({
-  prompt: import_zod8.z.string(),
+  /** A portrait, an outfit, or a mirror has none of its own; the loader says where one is needed. */
+  prompt: import_zod8.z.string().optional(),
   category: import_zod8.z.string().optional(),
   width: import_zod8.z.number().int().optional(),
   height: import_zod8.z.number().int().optional(),
@@ -15429,7 +15436,24 @@ var NewAssetSchema = import_zod8.z.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: import_zod8.z.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: import_zod8.z.union([import_zod8.z.string().min(1), import_zod8.z.record(CharacterDirectionSchema, import_zod8.z.string().min(1))]).optional(),
+  /** `character` pro bases: a concept image that seeds the design. */
+  concept: import_zod8.z.string().min(1).optional(),
+  /** `character` pro bases: another character in the style whose look this one follows. */
+  styleCharacter: import_zod8.z.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), {
@@ -15440,59 +15464,95 @@ var CANDIDATE_OPTION = {
   comfyui: "numImages",
   scenario: "numOutputs"
 };
+var NewStyleSchema = import_zod8.z.object({
+  generator: import_zod8.z.enum(["character", "objectPro"]),
+  /** Where the style's art is written, inside the project. */
+  outDir: import_zod8.z.string().min(1).refine((dir) => !dir.split(/[\\/]/).includes("..") && !/^([a-z]:)?[\\/]/i.test(dir), {
+    message: "outDir must be a path inside the project"
+  }),
+  size: import_zod8.z.number().int().min(16).max(256).optional(),
+  mode: CharacterModeSchema.optional(),
+  directions: import_zod8.z.union([import_zod8.z.literal(4), import_zod8.z.literal(8)]).optional(),
+  template: import_zod8.z.string().min(1).optional(),
+  view: import_zod8.z.string().min(1).max(64).optional(),
+  proportions: CharacterProportionsSchema.optional(),
+  isometric: import_zod8.z.boolean().optional(),
+  textGuidanceScale: import_zod8.z.number().min(1).max(20).optional(),
+  enhancePrompt: import_zod8.z.boolean().optional(),
+  promptPrefix: import_zod8.z.string().optional(),
+  promptSuffix: import_zod8.z.string().optional(),
+  palette: import_zod8.z.array(import_zod8.z.string().regex(/^#?[0-9a-f]{6}$/i, "expected a six-digit hex colour")).max(256).optional()
+}).strict();
+var PatchAssetEdit = import_zod8.z.object({
+  action: import_zod8.z.literal("patch-asset"),
+  assetId: import_zod8.z.string().min(1),
+  patch: AssetPatchSchema
+}).strict();
+var AddAssetEdit = import_zod8.z.object({
+  action: import_zod8.z.literal("add-asset"),
+  assetId: import_zod8.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  asset: NewAssetSchema
+}).strict();
+var SetSourceEdit = import_zod8.z.object({
+  action: import_zod8.z.literal("set-source"),
+  assetId: import_zod8.z.string().min(1),
+  styleId: import_zod8.z.string().min(1),
+  /** Manifest-relative path of the art that stands in for this asset in this style. */
+  source: import_zod8.z.string().min(1)
+}).strict();
+var ClearSourceEdit = import_zod8.z.object({
+  action: import_zod8.z.literal("clear-source"),
+  assetId: import_zod8.z.string().min(1),
+  styleId: import_zod8.z.string().min(1)
+}).strict();
+var PatchStyleEdit = import_zod8.z.object({
+  action: import_zod8.z.literal("patch-style"),
+  styleId: import_zod8.z.string().min(1),
+  patch: import_zod8.z.object({
+    /** Candidates per generation, written to the provider's own option. */
+    candidates: import_zod8.z.number().int().min(1).max(64).optional(),
+    /** Empty clears the style's own value (inherit, or the default). */
+    promptPrefix: import_zod8.z.string().optional(),
+    promptSuffix: import_zod8.z.string().optional(),
+    /** `#rrggbb` values; null or empty clears the style's own palette. */
+    palette: import_zod8.z.array(import_zod8.z.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: import_zod8.z.boolean().optional(),
+    /** Provider view name (PixelLab: low top-down, high top-down, side); empty clears. */
+    view: import_zod8.z.string().max(64).nullable().optional(),
+    /** pixflux only; null clears the style's own value. */
+    noBackground: import_zod8.z.boolean().nullable().optional()
+  }).strict().refine((patch) => Object.keys(patch).length > 0, { message: "nothing to change" })
+}).strict();
+var AddStyleEdit = import_zod8.z.object({
+  action: import_zod8.z.literal("add-style"),
+  styleId: import_zod8.z.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: import_zod8.z.string().min(1).optional(),
+  /** Manifest bytes the page last saw; a mismatch refuses the write. */
+  expectedSha256: HexSha
+};
+var SingleEdit = import_zod8.z.discriminatedUnion("action", [PatchAssetEdit, AddAssetEdit, SetSourceEdit, ClearSourceEdit, PatchStyleEdit, AddStyleEdit]);
 var ManifestEditSchema = import_zod8.z.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.
+   */
   import_zod8.z.object({
-    action: import_zod8.z.literal("patch-asset"),
-    /** Workspace project id; omitted for a single-project gallery. */
-    project: import_zod8.z.string().min(1).optional(),
-    assetId: import_zod8.z.string().min(1),
-    /** Manifest bytes the page last saw; a mismatch refuses the write. */
-    expectedSha256: HexSha,
-    patch: AssetPatchSchema
-  }).strict(),
-  import_zod8.z.object({
-    action: import_zod8.z.literal("add-asset"),
-    project: import_zod8.z.string().min(1).optional(),
-    assetId: import_zod8.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
-    expectedSha256: HexSha,
-    asset: NewAssetSchema
-  }).strict(),
-  import_zod8.z.object({
-    action: import_zod8.z.literal("set-source"),
-    project: import_zod8.z.string().min(1).optional(),
-    assetId: import_zod8.z.string().min(1),
-    styleId: import_zod8.z.string().min(1),
-    /** Manifest-relative path of the art that stands in for this asset in this style. */
-    source: import_zod8.z.string().min(1),
-    expectedSha256: HexSha
-  }).strict(),
-  import_zod8.z.object({
-    action: import_zod8.z.literal("clear-source"),
-    project: import_zod8.z.string().min(1).optional(),
-    assetId: import_zod8.z.string().min(1),
-    styleId: import_zod8.z.string().min(1),
-    expectedSha256: HexSha
-  }).strict(),
-  import_zod8.z.object({
-    action: import_zod8.z.literal("patch-style"),
-    project: import_zod8.z.string().min(1).optional(),
-    styleId: import_zod8.z.string().min(1),
-    expectedSha256: HexSha,
-    patch: import_zod8.z.object({
-      /** Candidates per generation, written to the provider's own option. */
-      candidates: import_zod8.z.number().int().min(1).max(64).optional(),
-      /** Empty clears the style's own value (inherit, or the default). */
-      promptPrefix: import_zod8.z.string().optional(),
-      promptSuffix: import_zod8.z.string().optional(),
-      /** `#rrggbb` values; null or empty clears the style's own palette. */
-      palette: import_zod8.z.array(import_zod8.z.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: import_zod8.z.boolean().optional(),
-      /** Provider view name (PixelLab: low top-down, high top-down, side); empty clears. */
-      view: import_zod8.z.string().max(64).nullable().optional(),
-      /** pixflux only; null clears the style's own value. */
-      noBackground: import_zod8.z.boolean().nullable().optional()
-    }).strict().refine((patch) => Object.keys(patch).length > 0, { message: "nothing to change" })
+    action: import_zod8.z.literal("batch"),
+    ...Envelope,
+    edits: import_zod8.z.array(SingleEdit).min(1).max(64)
   }).strict()
 ]);
 var ManifestDriftError = class extends Error {
@@ -15541,6 +15601,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);
@@ -15618,6 +15690,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;
   }
@@ -15645,11 +15726,10 @@ function applyEdit(raw, edit) {
     else delete asset.tags;
   }
 }
-async function applyManifestEdit(manifestPath, edit) {
+async function withCandidate(manifestPath, edit, use, unchanged) {
   const absolute = import_node_path27.default.resolve(manifestPath);
   const original = await (0, import_promises20.readFile)(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);
@@ -15660,25 +15740,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 = import_node_path27.default.join(
     import_node_path27.default.dirname(absolute),
     `.${import_node_path27.default.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
   );
   try {
     await (0, import_promises20.writeFile)(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 (0, import_promises20.rename)(tmp, absolute);
+    return await use({ absolute, original, next, tmp, specs });
   } finally {
     await (0, import_promises20.rm)(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 (0, import_promises20.rename)(tmp, absolute);
+      return { manifestPath: absolute, sha256: sha256(next), changed: true };
+    },
+    (absolute, original) => ({ manifestPath: absolute, sha256: sha256(original), changed: false })
+  );
 }
 
 // src/pipeline/hand-edit.ts
@@ -15929,62 +16019,103 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
   return openExternal(file, command);
 }
 
-// src/gallery/skeleton.ts
+// src/gallery/upload.ts
 var import_node_fs25 = require("fs");
 var import_promises22 = require("fs/promises");
 var import_node_path29 = __toESM(require("path"), 1);
 var import_zod10 = require("zod");
-var SkeletonEstimateRequestSchema = import_zod10.z.object({
+var MAX_UPLOAD_BYTES = 8 * 1024 * 1024;
+var UploadImageSchema = import_zod10.z.object({
+  action: import_zod10.z.literal("upload-image"),
   project: import_zod10.z.string().min(1).optional(),
-  styleId: import_zod10.z.string().min(1),
-  assetId: import_zod10.z.string().min(1),
-  frames: import_zod10.z.number().int().min(3).max(15).optional()
+  /** Manifest-relative destination, ending .png, .jpg, or .jpeg. */
+  path: import_zod10.z.string().min(1),
+  base64: import_zod10.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_UPLOAD_BYTES / 3) * 4),
+  /** Replace a file already at `path`. */
+  overwrite: import_zod10.z.boolean().optional()
 }).strict();
-var SkeletonAnimationRequestSchema = import_zod10.z.object({
-  action: import_zod10.z.literal("create-skeleton-animation"),
-  project: import_zod10.z.string().min(1).optional(),
-  expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/),
-  styleId: import_zod10.z.string().min(1),
+async function saveProjectImage(root, request) {
+  const file = import_node_path29.default.resolve(root, request.path);
+  const relative = import_node_path29.default.relative(root, file);
+  if (relative.startsWith("..") || import_node_path29.default.isAbsolute(relative)) {
+    throw new ManifestEditError("an upload must stay inside the project");
+  }
+  const extension = import_node_path29.default.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 ((0, import_node_fs25.existsSync)(file) && !request.overwrite) {
+    throw new ManifestEditError(`${relative.split(import_node_path29.default.sep).join("/")} already exists; choose another name, or replace it`);
+  }
+  await (0, import_promises22.mkdir)(import_node_path29.default.dirname(file), { recursive: true });
+  await (0, import_promises22.writeFile)(file, bytes);
+  return relative.split(import_node_path29.default.sep).join("/");
+}
+
+// src/gallery/skeleton.ts
+var import_node_fs26 = require("fs");
+var import_promises23 = require("fs/promises");
+var import_node_path30 = __toESM(require("path"), 1);
+var import_zod11 = require("zod");
+var SkeletonEstimateRequestSchema = import_zod11.z.object({
+  project: import_zod11.z.string().min(1).optional(),
+  styleId: import_zod11.z.string().min(1),
+  assetId: import_zod11.z.string().min(1),
+  frames: import_zod11.z.number().int().min(3).max(15).optional()
+}).strict();
+var SkeletonAnimationRequestSchema = import_zod11.z.object({
+  action: import_zod11.z.literal("create-skeleton-animation"),
+  project: import_zod11.z.string().min(1).optional(),
+  expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/),
+  styleId: import_zod11.z.string().min(1),
   /** The sprite the animation poses. */
-  from: import_zod10.z.string().min(1),
-  assetId: import_zod10.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
+  from: import_zod11.z.string().min(1),
+  assetId: import_zod11.z.string().min(1).regex(/^[^/\\]+$/, "asset ids cannot contain slashes"),
   /** The motion, sent as PixelLab's `action`. */
-  prompt: import_zod10.z.string().min(1),
+  prompt: import_zod11.z.string().min(1),
   direction: CharacterDirectionSchema,
-  description: import_zod10.z.string().min(1).optional(),
-  skeletonTemplate: import_zod10.z.string().min(1).optional(),
+  description: import_zod11.z.string().min(1).optional(),
+  skeletonTemplate: import_zod11.z.string().min(1).optional(),
   /** Manifest-relative JSON path inside the project. */
-  keypointsFile: import_zod10.z.string().min(1),
+  keypointsFile: import_zod11.z.string().min(1),
   /** Poses to write to `keypointsFile`; omitted to use a file that already exists. */
   set: SkeletonSetSchema.optional(),
   /** Replace an existing `keypointsFile` with `set`. */
-  overwrite: import_zod10.z.boolean().optional()
+  overwrite: import_zod11.z.boolean().optional()
 }).strict();
-var SkeletonKeypointsUpdateSchema = import_zod10.z.object({
-  action: import_zod10.z.literal("update-skeleton-keypoints"),
-  project: import_zod10.z.string().min(1).optional(),
-  styleId: import_zod10.z.string().min(1),
-  assetId: import_zod10.z.string().min(1),
+var SkeletonKeypointsUpdateSchema = import_zod11.z.object({
+  action: import_zod11.z.literal("update-skeleton-keypoints"),
+  project: import_zod11.z.string().min(1).optional(),
+  styleId: import_zod11.z.string().min(1),
+  assetId: import_zod11.z.string().min(1),
   /** The file's SHA-256 when the page loaded it; anything else on disk is a concurrent edit. */
-  expectedSha256: import_zod10.z.string().regex(/^[0-9a-f]{64}$/),
+  expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/),
   set: SkeletonSetSchema
 }).strict();
 async function createSkeletonAnimation(manifestPath, request) {
-  const root = import_node_path29.default.dirname(import_node_path29.default.resolve(manifestPath));
-  const file = import_node_path29.default.resolve(root, request.keypointsFile);
-  const relative = import_node_path29.default.relative(root, file);
-  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || import_node_path29.default.isAbsolute(relative)) {
+  const root = import_node_path30.default.dirname(import_node_path30.default.resolve(manifestPath));
+  const file = import_node_path30.default.resolve(root, request.keypointsFile);
+  const relative = import_node_path30.default.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || import_node_path30.default.isAbsolute(relative)) {
     throw new ManifestEditError("the keypoints file must be a .json path inside the project");
   }
-  const existed = (0, import_node_fs25.existsSync)(file);
+  const existed = (0, import_node_fs26.existsSync)(file);
   let previous = null;
   if (request.set) {
     if (existed && !request.overwrite) {
       throw new ManifestEditError(`${request.keypointsFile} already exists; choose another path, or replace it`);
     }
-    if (existed) previous = await (0, import_promises22.readFile)(file);
-    await (0, import_promises22.mkdir)(import_node_path29.default.dirname(file), { recursive: true });
-    await (0, import_promises22.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
+    if (existed) previous = await (0, import_promises23.readFile)(file);
+    await (0, import_promises23.mkdir)(import_node_path30.default.dirname(file), { recursive: true });
+    await (0, import_promises23.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
   } else if (!existed) {
     throw new ManifestEditError(`${request.keypointsFile} does not exist; paste poses or estimate them from the sprite`);
   }
@@ -15999,7 +16130,7 @@ async function createSkeletonAnimation(manifestPath, request) {
         revision: {
           mode: "animate-skeleton",
           from: request.from,
-          keypointsFile: relative.split(import_node_path29.default.sep).join("/"),
+          keypointsFile: relative.split(import_node_path30.default.sep).join("/"),
           direction: request.direction,
           ...request.description ? { description: request.description } : {},
           ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
@@ -16008,8 +16139,8 @@ async function createSkeletonAnimation(manifestPath, request) {
     });
   } catch (error) {
     if (request.set) {
-      if (previous) await (0, import_promises22.writeFile)(file, previous);
-      else await (0, import_promises22.rm)(file, { force: true });
+      if (previous) await (0, import_promises23.writeFile)(file, previous);
+      else await (0, import_promises23.rm)(file, { force: true });
     }
     throw error;
   }
@@ -16020,56 +16151,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 = import_node_path29.default.relative(ctx.loaded.root, file);
-  if (relative.startsWith("..") || import_node_path29.default.isAbsolute(relative)) {
+  const relative = import_node_path30.default.relative(ctx.loaded.root, file);
+  if (relative.startsWith("..") || import_node_path30.default.isAbsolute(relative)) {
     throw new ManifestEditError(`${key}'s keypoints file is outside the project; edit it by hand`);
   }
-  const current = (0, import_node_fs25.existsSync)(file) ? sha256(await (0, import_promises22.readFile)(file)) : null;
+  const current = (0, import_node_fs26.existsSync)(file) ? sha256(await (0, import_promises23.readFile)(file)) : null;
   if (current !== request.expectedSha256) {
     throw Object.assign(
-      new Error(`${relative.split(import_node_path29.default.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
+      new Error(`${relative.split(import_node_path30.default.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
       { status: 409 }
     );
   }
-  await (0, import_promises22.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
-  return relative.split(import_node_path29.default.sep).join("/");
+  await (0, import_promises23.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
+  return relative.split(import_node_path30.default.sep).join("/");
 }
 
 // src/gallery/edit.ts
-var Base64 = import_zod11.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
-var HandEditRequestSchema = import_zod11.z.discriminatedUnion("action", [
-  import_zod11.z.object({
-    action: import_zod11.z.literal("start-edit"),
-    project: import_zod11.z.string().min(1).optional(),
-    assetId: import_zod11.z.string().min(1),
-    styleId: import_zod11.z.string().min(1),
-    expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/),
+var Base64 = import_zod12.z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = import_zod12.z.discriminatedUnion("action", [
+  import_zod12.z.object({
+    action: import_zod12.z.literal("start-edit"),
+    project: import_zod12.z.string().min(1).optional(),
+    assetId: import_zod12.z.string().min(1),
+    styleId: import_zod12.z.string().min(1),
+    expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: import_zod11.z.boolean().optional()
+    open: import_zod12.z.boolean().optional()
   }).strict(),
-  import_zod11.z.object({
-    action: import_zod11.z.literal("detach-edit"),
-    project: import_zod11.z.string().min(1).optional(),
-    assetId: import_zod11.z.string().min(1),
-    styleId: import_zod11.z.string().min(1),
-    expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/)
+  import_zod12.z.object({
+    action: import_zod12.z.literal("detach-edit"),
+    project: import_zod12.z.string().min(1).optional(),
+    assetId: import_zod12.z.string().min(1),
+    styleId: import_zod12.z.string().min(1),
+    expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/)
   }).strict(),
   /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
-  import_zod11.z.object({
-    action: import_zod11.z.literal("save-edit"),
-    project: import_zod11.z.string().min(1).optional(),
-    assetId: import_zod11.z.string().min(1),
-    styleId: import_zod11.z.string().min(1),
-    expectedSha256: import_zod11.z.string().regex(/^[0-9a-f]{64}$/),
+  import_zod12.z.object({
+    action: import_zod12.z.literal("save-edit"),
+    project: import_zod12.z.string().min(1).optional(),
+    assetId: import_zod12.z.string().min(1),
+    styleId: import_zod12.z.string().min(1),
+    expectedSha256: import_zod12.z.string().regex(/^[0-9a-f]{64}$/),
     /** The flattened image; for a frame set, `frames` instead. */
     png: Base64.min(1).optional(),
     /** Every frame of a set, tagged with the role it was opened under (null for one added in the editor). */
-    frames: import_zod11.z.array(import_zod11.z.object({ role: import_zod11.z.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
+    frames: import_zod12.z.array(import_zod12.z.object({ role: import_zod12.z.string().min(1).nullable(), png: Base64.min(1) }).strict()).min(1).max(256).optional(),
     /** The editor's layered project file, kept beside the edit. */
     pxo: Base64.optional(),
     /** Editor identity from the bridge's ready message. */
-    editor: import_zod11.z.string().min(1).max(200),
-    protocol: import_zod11.z.number().int().positive()
+    editor: import_zod12.z.string().min(1).max(200),
+    protocol: import_zod12.z.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -16110,6 +16241,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(import_node_path31.default.dirname(import_node_path31.default.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");
@@ -16153,19 +16299,35 @@ function createGalleryEditHandler(opts) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = import_node_path30.default.relative(process.cwd(), result.manifestPath);
+      const relative = import_node_path31.default.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
-      const subject = parsed.data.action === "patch-style" ? `style ${parsed.data.styleId}` : parsed.data.action === "set-source" || parsed.data.action === "clear-source" ? `${parsed.data.styleId}/${parsed.data.assetId} source` : parsed.data.assetId;
-      log(`  manifest edited: ${parsed.data.action === "add-asset" ? "added" : "changed"} ${subject} in ${shown}`);
+      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 (0, import_node_crypto6.createHash)("sha256").update(import_node_path31.default.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return (0, import_node_crypto6.createHash)("sha256").update(import_node_path32.default.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -16184,9 +16346,9 @@ function describeHistory(media, entry, cacheDir) {
   return (entry.history ?? []).map((generation, i) => {
     const outputs = generation.outputs.map((output) => {
       const mediaType = output.mediaType ?? MediaType.PNG;
-      const file = import_node_path31.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = import_node_path32.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if ((0, import_node_fs26.existsSync)(file)) {
+      if ((0, import_node_fs27.existsSync)(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -16218,7 +16380,7 @@ function describeHistory(media, entry, cacheDir) {
 var MAX_COMPARED_BYTES = 8 * 1024 * 1024;
 async function samePixels(a, b) {
   try {
-    const [left, right] = await Promise.all([(0, import_promises23.readFile)(a), (0, import_promises23.readFile)(b)]);
+    const [left, right] = await Promise.all([(0, import_promises24.readFile)(a), (0, import_promises24.readFile)(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -16284,7 +16446,7 @@ function describeCharacter(spec, entry) {
 }
 async function fileInfo(absolutePath) {
   try {
-    const info = await (0, import_promises23.stat)(absolutePath);
+    const info = await (0, import_promises24.stat)(absolutePath);
     return info.isFile() ? { bytes: info.size, modifiedAt: info.mtime.toISOString() } : null;
   } catch {
     return null;
@@ -16316,10 +16478,10 @@ async function describeOutput(media, root, absolutePath, recorded = {}) {
 async function describeQuality(media, root, inspection) {
   const outputPaths = inspection.outputs ?? [inspection.output];
   const outputs = await Promise.all(
-    outputPaths.map((file) => describeOutput(media, root, import_node_path31.default.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, import_node_path32.default.resolve(root, file)))
   );
-  const recordPath = import_node_path31.default.resolve(root, inspection.record);
-  const recordExists = (0, import_node_fs26.existsSync)(recordPath);
+  const recordPath = import_node_path32.default.resolve(root, inspection.record);
+  const recordExists = (0, import_node_fs27.existsSync)(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -16338,7 +16500,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(import_node_path31.default.resolve(root, inspection.output), root),
+    output: portableOutputPath(import_node_path32.default.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -16376,9 +16538,9 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await (0, import_promises23.readFile)(loaded.path, "utf8");
+  const manifestText = await (0, import_promises24.readFile)(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = import_node_path31.default.resolve(import_node_path31.default.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = import_node_path32.default.resolve(import_node_path32.default.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -16402,12 +16564,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = import_node_path31.default.resolve(root, spec.source);
+        const editPath = import_node_path32.default.resolve(root, spec.source);
         const memberCount = sourceIsStem(spec.source, entry, root) ? entry.outputs.length : 1;
         const editShas = await Promise.all(
           Array.from({ length: memberCount }, async (_, index) => {
             const file = sourceOutputPath(spec.source, entry, index, root);
-            return { file, sha256: (0, import_node_fs26.existsSync)(file) ? await sha256File(file) : null };
+            return { file, sha256: (0, import_node_fs27.existsSync)(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -16415,7 +16577,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && (0, import_node_fs26.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && (0, import_node_fs27.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -16451,8 +16613,8 @@ async function buildGallerySnapshot(opts) {
         editStatus = edits.some((member) => !member.exists) ? "missing" : editChanged.every((changed) => !changed) ? "same" : regenerated ? "regenerated-since" : "edited";
       }
     } else if (spec.source) {
-      outputs = [await describeOutput(media, root, import_node_path31.default.resolve(root, spec.source))];
-    } else if (!entry && (0, import_node_fs26.existsSync)(spec.outFile)) {
+      outputs = [await describeOutput(media, root, import_node_path32.default.resolve(root, spec.source))];
+    } else if (!entry && (0, import_node_fs27.existsSync)(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -16653,7 +16815,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: import_node_path31.default.resolve(opts.lockPath),
+      lock: import_node_path32.default.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -16679,7 +16841,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = import_node_path31.default.dirname(import_node_path31.default.resolve(opts.workspacePath));
+  const dir = import_node_path32.default.dirname(import_node_path32.default.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -16722,11 +16884,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: import_node_path31.default.resolve(lockPath),
+        lock: import_node_path32.default.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises23.readFile)(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises24.readFile)(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -16738,8 +16900,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: import_node_path31.default.resolve(lockPath),
-        root: import_node_path31.default.dirname(manifestPath),
+        lock: import_node_path32.default.resolve(lockPath),
+        root: import_node_path32.default.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -16766,7 +16928,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: import_node_path31.default.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: import_node_path32.default.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -16783,7 +16945,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 
 // src/gallery/page.ts
-var import_node_fs27 = require("fs");
+var import_node_fs28 = require("fs");
 
 // src/gallery/client-bundle.ts
 var import_node_module = require("module");
@@ -16823,8 +16985,8 @@ var client;
 function clientAssets() {
   const prebuilt = new URL("gallery.js", CLIENT_DIR);
   client ??= {
-    css: (0, import_node_fs27.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
-    js: (0, import_node_fs27.existsSync)(prebuilt) ? (0, import_node_fs27.readFileSync)(prebuilt, "utf8") : bundleGalleryClient()
+    css: (0, import_node_fs28.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
+    js: (0, import_node_fs28.existsSync)(prebuilt) ? (0, import_node_fs28.readFileSync)(prebuilt, "utf8") : bundleGalleryClient()
   };
   return client;
 }
@@ -16866,6 +17028,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>
@@ -16951,10 +17114,10 @@ var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download
 
 // src/editor/install.ts
 var import_node_crypto7 = require("crypto");
-var import_node_fs28 = require("fs");
-var import_promises24 = require("fs/promises");
+var import_node_fs29 = require("fs");
+var import_promises25 = require("fs/promises");
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_path33 = __toESM(require("path"), 1);
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -16965,15 +17128,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return import_node_path32.default.resolve(override);
-  if (process.platform === "darwin") return import_node_path32.default.join(import_node_os3.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return import_node_path33.default.resolve(override);
+  if (process.platform === "darwin") return import_node_path33.default.join(import_node_os3.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return import_node_path32.default.join(process.env.LOCALAPPDATA ?? import_node_path32.default.join(import_node_os3.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return import_node_path33.default.join(process.env.LOCALAPPDATA ?? import_node_path33.default.join(import_node_os3.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return import_node_path32.default.join(process.env.XDG_CACHE_HOME ?? import_node_path32.default.join(import_node_os3.default.homedir(), ".cache"), "pixelkiln", "tools");
+  return import_node_path33.default.join(process.env.XDG_CACHE_HOME ?? import_node_path33.default.join(import_node_os3.default.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return import_node_path32.default.join(root, "pixelorama", pin.release ?? "unpublished");
+  return import_node_path33.default.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -16983,7 +17146,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises24.readFile)(file)).digest("hex");
+    return (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises25.readFile)(file)).digest("hex");
   } catch {
     return null;
   }
@@ -16996,8 +17159,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = import_node_path32.default.join(dir, name);
-    const info = (0, import_node_fs28.existsSync)(file) ? await (0, import_promises24.stat)(file).catch(() => null) : null;
+    const file = import_node_path33.default.join(dir, name);
+    const info = (0, import_node_fs29.existsSync)(file) ? await (0, import_promises25.stat)(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -17026,7 +17189,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await (0, import_promises24.mkdir)(dir, { recursive: true });
+  await (0, import_promises25.mkdir)(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -17054,13 +17217,13 @@ async function installEditor(opts = {}) {
     if (digest2 !== expected.sha256) {
       throw new EditorInstallError(`${name}: sha256 ${digest2.slice(0, 12)}\u2026 does not match the pinned ${expected.sha256.slice(0, 12)}\u2026`, name);
     }
-    const final = import_node_path32.default.join(dir, name);
+    const final = import_node_path33.default.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await (0, import_promises24.writeFile)(tmp, bytes);
-      await (0, import_promises24.rename)(tmp, final);
+      await (0, import_promises25.writeFile)(tmp, bytes);
+      await (0, import_promises25.rename)(tmp, final);
     } finally {
-      await (0, import_promises24.rm)(tmp, { force: true });
+      await (0, import_promises25.rm)(tmp, { force: true });
     }
     fetchedBytes += bytes.length;
     downloaded.push(name);
@@ -17100,12 +17263,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[import_node_path32.default.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[import_node_path33.default.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
-var import_promises25 = require("fs/promises");
-var import_node_path33 = __toESM(require("path"), 1);
+var import_promises26 = require("fs/promises");
+var import_node_path34 = __toESM(require("path"), 1);
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -17178,7 +17341,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await (0, import_promises25.readFile)(import_node_path33.default.join(dir, name));
+        bytes = await (0, import_promises26.readFile)(import_node_path34.default.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -17195,7 +17358,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 var import_node_crypto8 = require("crypto");
 var import_node_http2 = require("http");
-var import_promises26 = require("fs/promises");
+var import_promises27 = require("fs/promises");
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -17223,7 +17386,7 @@ async function readJsonBody(req) {
 async function serveGallery(opts) {
   const log = opts.onProgress ?? (() => {
   });
-  const session = opts.edit || opts.generate || opts.editor || opts.skeleton ? (0, import_node_crypto8.randomBytes)(16).toString("hex") : null;
+  const session = opts.edit || opts.generate || opts.editor || opts.skeleton || opts.price ? (0, import_node_crypto8.randomBytes)(16).toString("hex") : null;
   let media = /* @__PURE__ */ new Map();
   let loading = null;
   const reviewAssets = /* @__PURE__ */ new Map();
@@ -17298,6 +17461,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 {
@@ -17365,7 +17539,7 @@ async function serveGallery(opts) {
         const asset = reviewAssets.get(jobId)?.get(url2.pathname);
         if (!asset) return fail(404, "no such review asset");
         try {
-          const bytes = await (0, import_promises26.readFile)(asset.path);
+          const bytes = await (0, import_promises27.readFile)(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -17448,7 +17622,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await (0, import_promises26.readFile)(asset.path);
+          bytes = await (0, import_promises27.readFile)(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -17492,27 +17666,27 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 var import_node_crypto9 = require("crypto");
-var import_zod12 = require("zod");
-var GenerateRequestSchema = import_zod12.z.object({
-  project: import_zod12.z.string().min(1).optional(),
-  keys: import_zod12.z.array(import_zod12.z.string().min(1)).min(1).max(500),
+var import_zod13 = require("zod");
+var GenerateRequestSchema = import_zod13.z.object({
+  project: import_zod13.z.string().min(1).optional(),
+  keys: import_zod13.z.array(import_zod13.z.string().min(1)).min(1).max(500),
   /**
    * Regenerate work that is up to date, as `gen --force` does, and let the
    * fetch replace a locally modified or untracked file. With `restore`, put
    * the recorded bytes back over a modified file.
    */
-  force: import_zod12.z.boolean().optional(),
+  force: import_zod13.z.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: import_zod12.z.boolean().optional(),
+  resume: import_zod13.z.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: import_zod12.z.boolean().optional(),
+  refresh: import_zod13.z.boolean().optional(),
   /** Put recorded outputs back on disk from the cache or the provider, without generating. */
-  restore: import_zod12.z.boolean().optional(),
+  restore: import_zod13.z.boolean().optional(),
   /**
    * Bring a replaced generation back: 1-based position in the record's
    * history (newest first) or an output hash prefix. One key at a time.
    */
-  revert: import_zod12.z.string().min(1).max(64).optional()
+  revert: import_zod13.z.string().min(1).max(64).optional()
 }).strict().refine((request) => [request.resume, request.refresh, request.restore, request.revert !== void 0].filter(Boolean).length <= 1, {
   message: "resume, refresh, restore, and revert are exclusive"
 }).refine((request) => request.revert === void 0 || request.keys.length === 1, { message: "revert takes one key" });
@@ -17636,6 +17810,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") {
@@ -17663,36 +17901,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) {
@@ -17822,19 +18032,19 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-var import_promises27 = require("fs/promises");
-var import_node_fs29 = require("fs");
-var import_node_path34 = __toESM(require("path"), 1);
+var import_promises28 = require("fs/promises");
+var import_node_fs30 = require("fs");
+var import_node_path35 = __toESM(require("path"), 1);
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
 async function loadClaims(lockPaths, opts = {}) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
-    if (!(0, import_node_fs29.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!(0, import_node_fs30.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await (0, import_promises27.readFile)(p, "utf8")));
+      parsed = parseLock(JSON.parse(await (0, import_promises28.readFile)(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -17938,20 +18148,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = import_node_path34.default.resolve(ownManifestPath);
+  const own = import_node_path35.default.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => import_node_path34.default.join(import_node_path34.default.dirname(import_node_path34.default.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => import_node_path35.default.join(import_node_path35.default.dirname(import_node_path35.default.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (import_node_path34.default.resolve(siblingManifestPath) === own) continue;
-    if (!(0, import_node_fs29.existsSync)(siblingManifestPath)) continue;
+    if (import_node_path35.default.resolve(siblingManifestPath) === own) continue;
+    if (!(0, import_node_fs30.existsSync)(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: import_node_path34.default.basename(import_node_path34.default.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: import_node_path35.default.basename(import_node_path35.default.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -18071,8 +18281,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-var import_promises28 = require("fs/promises");
-var import_node_path35 = __toESM(require("path"), 1);
+var import_promises29 = require("fs/promises");
+var import_node_path36 = __toESM(require("path"), 1);
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -18238,7 +18448,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: import_node_path35.default.relative(process.cwd(), ctx.importDir) || "."
+    importDir: import_node_path36.default.relative(process.cwd(), ctx.importDir) || "."
   });
   const byId = new Map(orphans.map((o) => [o.id, o]));
   const existingTags = new Map(orphans.map((o) => [o.id, o.tags]));
@@ -18294,10 +18504,10 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE2)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = import_node_path35.default.join("_salvaged", `${assetId}.png`);
-            const outFile = import_node_path35.default.resolve(ctx.importDir, rel);
-            await (0, import_promises28.mkdir)(import_node_path35.default.dirname(outFile), { recursive: true });
-            await (0, import_promises28.writeFile)(outFile, buf);
+            const rel = import_node_path36.default.join("_salvaged", `${assetId}.png`);
+            const outFile = import_node_path36.default.resolve(ctx.importDir, rel);
+            await (0, import_promises29.mkdir)(import_node_path36.default.dirname(outFile), { recursive: true });
+            await (0, import_promises29.writeFile)(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -18329,7 +18539,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, import_node_path35.default.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, import_node_path36.default.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -18353,9 +18563,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log, characters: characterMembers });
-      const raw = JSON.parse(await (0, import_promises28.readFile)(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await (0, import_promises29.readFile)(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await (0, import_promises28.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await (0, import_promises29.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       if (characterAssetIds.length) result.characterAssetIds = characterAssetIds;
       return result;