pixelkiln 0.38.0 → 0.40.0

package/dist/cli.js

@@ -67,8 +67,8 @@ function exitCodeFor(err) {
 }
 
 // src/cli/main.ts
-import { existsSync as existsSync31 } from "fs";
-import { readFile as readFile27 } from "fs/promises";
+import { existsSync as existsSync32 } from "fs";
+import { readFile as readFile28 } from "fs/promises";
 
 // src/cli/args.ts
 import path from "path";
@@ -411,7 +411,7 @@ function parseArgs(argv) {
 }
 
 // src/cli/help.ts
-var HELP = `pixelkiln \u2014 manifest-driven pixel art generation
+var HELP = `pixelkiln: manifest-driven pixel art generation
 
   pixelkiln <command> [options]
 
@@ -428,7 +428,7 @@ Commands
             --generation <n|hash> brings a previous generation back instead.
   history   List the generations each asset has replaced and can restore.
   adopt     Match existing account objects to files already in the repo.
-  accept    Keep existing art after a style reword \u2014 re-baseline, do not regenerate.
+  accept    Keep existing art after a style reword. Re-baseline, do not regenerate.
   salvage   Triage account objects no lockfile claims. Recovers usable art.
             One session per matching style unless --style forces a single one.
   audit     Measure how consistently a style's assets hold together. Offline.
@@ -618,10 +618,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path43) {
+async function sha256File(path44) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path43);
+    const stream = createReadStream(path44);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -647,13 +647,26 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
       palette: spec.palette,
       // `noBackground` only reaches the wire for pixflux; the tile fields are
       // undefined for every other generator. `tileSize` is intentionally
-      // absent — width/height are derived from it, so it is already covered.
+      // absent; width/height are derived from it, so it is already covered.
       noBackground: spec.generator === "pixflux" || spec.provider !== "pixellab" ? spec.noBackground : void 0,
       tileType: spec.tileType,
       tileView: spec.tileView,
       tileFeature: spec.tileFeature,
       outlineMode: spec.outlineMode,
       styleImages: styleImageHashes,
+      // A character family: the engine and rotations of a base, the parent's
+      // generated bytes for a state or animation (so a regenerated parent
+      // makes its children stale), and each shape's own settings.
+      character: spec.character ? {
+        kind: spec.character.kind,
+        mode: spec.character.mode,
+        directions: spec.character.directions,
+        template: spec.character.template,
+        parent: spec.character.parentAssetId,
+        parentSha256: spec.character.parentSha256 ?? null,
+        state: spec.character.state,
+        animation: spec.character.animation
+      } : void 0,
       revision: spec.revision ? {
         mode: spec.revision.mode,
         from: spec.revision.sourceAssetId,
@@ -677,7 +690,7 @@ import path2 from "path";
 // src/types.ts
 import { z } from "zod";
 var MediaTypeSchema = z.enum(["image/png", "image/gif"]);
-var GeneratorSchema = z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames"]);
+var GeneratorSchema = z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character"]);
 var GridConfidenceSchema = z.enum(["low", "medium", "high"]);
 var RevisionModeSchema = z.enum(["image-to-image", "inpaint", "outpaint"]);
 function tileVariationCount(descriptions) {
@@ -735,6 +748,77 @@ var QualityProfileSchema = QualityProfileObjectSchema.refine(
   (profile) => new Set(profile.palette.map((color) => color.replace(/^#/, "").toLowerCase())).size === profile.palette.length,
   { message: "quality palette colors must be unique", path: ["palette"] }
 );
+var CharacterDirectionSchema = z.enum([
+  "south",
+  "south-east",
+  "east",
+  "north-east",
+  "north",
+  "north-west",
+  "west",
+  "south-west"
+]);
+var CHARACTER_DIRECTIONS_8 = [
+  "south",
+  "south-east",
+  "east",
+  "north-east",
+  "north",
+  "north-west",
+  "west",
+  "south-west"
+];
+var CHARACTER_DIRECTIONS_4 = ["south", "west", "east", "north"];
+var CharacterModeSchema = z.enum(["standard", "v3", "pro"]);
+var CharacterAnimationModeSchema = z.enum(["template", "v3", "pro"]);
+var CharacterStateSchema = z.object({
+  /** The base character, or another state, in the same style. */
+  of: z.string().min(1),
+  /** Snap the edited rotations to the parent's colours. Off when the edit adds colours. */
+  paletteFromReference: z.boolean().default(false),
+  /** A larger canvas when the edit adds something big. Multiples of 4, no smaller than the parent. */
+  canvas: z.object({
+    width: z.number().int().min(16).max(256),
+    height: z.number().int().min(16).max(256)
+  }).strict().optional()
+}).strict();
+var CharacterAnimationSchema = z.object({
+  /** The character to animate: a base or a state in the same style. */
+  of: z.string().min(1),
+  /** A PixelLab template id (`walk`, `breathing-idle`, ...). Costs 1 generation; frame count is the template's. */
+  template: z.string().min(1).optional(),
+  /** Direction to animate. */
+  direction: CharacterDirectionSchema.default("south"),
+  /** Frames to generate without a template (v3). Even, 4 to 16. */
+  frames: z.number().int().min(4).max(16).optional(),
+  /** Playback rate recorded with the frames; PixelLab does not store one. */
+  fps: z.number().int().min(1).max(60).default(8),
+  /** v3 only: keep the resting pose as frame 0, so `frames` generated frames land as `frames + 1` files. */
+  keepFirstFrame: z.boolean().default(true),
+  /** `template` when a template is named, otherwise `v3`; `pro` for the sequential high-quality engine. */
+  mode: CharacterAnimationModeSchema.optional()
+}).strict().superRefine((animation, context) => {
+  if (animation.frames !== void 0 && animation.frames % 2 !== 0) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: "frames must be even", path: ["frames"] });
+  }
+  if (animation.template && animation.mode && animation.mode !== "template") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `a template animation cannot use mode "${animation.mode}"`,
+      path: ["mode"]
+    });
+  }
+  if (animation.template && animation.frames !== void 0) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "a template decides its own frame count; drop frames",
+      path: ["frames"]
+    });
+  }
+  if (!animation.template && animation.mode === "template") {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: "template mode needs a template", path: ["template"] });
+  }
+});
 var RevisionSchema = z.object({
   /** What kind of controlled change the provider workflow performs. */
   mode: RevisionModeSchema,
@@ -784,7 +868,7 @@ var StyleObjectSchema = z.object({
   /**
    * `tiles` generator only. Edge length of one tile, 16-256.
    *
-   * Ignored when `styleImages` is set — style mode takes the tile's shape
+   * Ignored when `styleImages` is set: style mode takes the tile's shape
    * and dimensions from the reference image, which is the whole reason to
    * use it against an existing sheet.
    */
@@ -798,7 +882,7 @@ var StyleObjectSchema = z.object({
    * independent variations:
    *
    *   roads    18-configuration path set
-   *   tileset  16-tile Wang corner set for a terrain transition — describe
+   *   tileset  16-tile Wang corner set for a terrain transition. Describe
    *            the asset as the transition itself ("fairway grass to rough
    *            meadow"), not as one terrain
    *   building floor/wall/doorway construction kit
@@ -816,7 +900,7 @@ var StyleObjectSchema = z.object({
    * surface into visible quilting, with a dark seam at every cell edge.
    * `segmentation` omits them and the same set tiles seamlessly.
    *
-   * Measured on a fairway-to-rough terrain set — the difference decided
+   * Measured on a fairway-to-rough terrain set, where the difference decided
    * whether the art was usable at all, so it is worth setting deliberately
    * rather than inheriting.
    */
@@ -825,7 +909,7 @@ var StyleObjectSchema = z.object({
    * `pixflux` only. Whether to strip the generated background.
    *
    * Defaults to true, which is right for the sprites this tool was built
-   * for — a prop or an icon wants to sit on whatever is behind it. It is
+   * for; a prop or an icon wants to sit on whatever is behind it. It is
    * wrong for anything that IS a scene: a cover banner, a splash, a
    * backdrop. The API's own default is false; forcing it true unconditionally
    * meant a full-bleed image came back as a small subject floating in a
@@ -833,12 +917,23 @@ var StyleObjectSchema = z.object({
    * override it.
    */
   noBackground: z.boolean().default(true),
+  /**
+   * `character` only. `standard` draws from a skeleton template for 1
+   * generation; `v3` is the highest quality at 2 to 9 by size; `pro` is a
+   * reference-based engine at 20 to 40 by size. States inherit the
+   * parent's engine; animations choose their own.
+   */
+  mode: CharacterModeSchema.optional(),
+  /** `character` only. Rotations per base or state. `v3` and `pro` always draw 8. */
+  directions: z.union([z.literal(4), z.literal(8)]).optional(),
+  /** `character` only. Body template: `mannequin` (default) or a quadruped (`bear`, `cat`, `dog`, `horse`, `lion`). */
+  template: z.string().min(1).optional(),
   /** Fixed seed for reproducibility where the endpoint supports it. */
   seed: z.number().int().optional(),
   /**
    * Forced palette, as `#rrggbb` values. `pixflux` only.
    *
-   * Unlike prose, this is a hard constraint — the API is handed a swatch
+   * Unlike prose, this is a hard constraint. The API is handed a swatch
    * image and the output is limited to those colours. Verified: a four-colour
    * Game Boy palette produced output containing exactly those four values.
    * Prose asking for the same thing does not reliably hold, which is why the
@@ -863,8 +958,8 @@ var StyleObjectSchema = z.object({
   /**
    * Composites this style's assets into declared cells of a sheet, rather
    * than letting `pack` derive a layout. Use it when the atlas coordinates
-   * are already load-bearing somewhere else — a tile engine naming tiles by
-   * cell, or saved data storing cell indices — since `pack`'s id-sorted grid
+   * are already load-bearing somewhere else, a tile engine naming tiles by
+   * cell or saved data storing cell indices, since `pack`'s id-sorted grid
    * moves every position when an asset is added or renamed.
    *
    * Assets in a mounted style declare their own `cell`; ones that do not are
@@ -889,7 +984,7 @@ var StyleObjectSchema = z.object({
   providerOptions: z.record(z.record(z.unknown())).default({})
 }).strict();
 var StyleSchema = StyleObjectSchema.refine((s) => !(s.tileFeature && s.styleImages.length), {
-  message: "tileFeature and styleImages cannot be combined \u2014 a connectable set derives its own tile geometry, so remove one or the other",
+  message: "tileFeature and styleImages cannot be combined; a connectable set derives its own tile geometry, so remove one or the other",
   path: ["tileFeature"]
 }).superRefine((style, ctx) => {
   if (style.quality && (style.generator === "tiles" || style.generator === "animation")) {
@@ -906,6 +1001,23 @@ var StyleSchema = StyleObjectSchema.refine((s) => !(s.tileFeature && s.styleImag
       path: ["enforcePalette"]
     });
   }
+  if (style.generator !== "character") {
+    for (const field of ["mode", "directions", "template"]) {
+      if (style[field] !== void 0) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `${field} applies to the character generator only`,
+          path: [field]
+        });
+      }
+    }
+  } else if (style.mode && style.mode !== "standard" && style.directions === 4) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `${style.mode} characters always have 8 directions`,
+      path: ["directions"]
+    });
+  }
 });
 var InheritedStyleSchema = StyleObjectSchema.partial().extend({
   extends: z.string().min(1),
@@ -938,14 +1050,14 @@ var AssetSchema = z.object({
   cell: z.tuple([z.number().int().min(0), z.number().int().min(0)]).optional(),
   /**
    * Path, relative to the manifest, of the art that goes on a mounted
-   * sheet — when that is not the raw generated output.
+   * sheet, when that is not the raw generated output.
    *
    * `mount` otherwise takes its pixels from the lockfile, which records
    * what the API returned. That is the wrong file whenever the art needs a
    * step pixelkiln does not perform: a palette reduction onto a sheet's
    * closed palette, a hand touch-up, an alignment shift. Without somewhere
    * to say so, the choice is to mount the unprocessed art or to abandon
-   * `mount` and composite by hand — and the hand-composited sheet is
+   * `mount` and composite by hand, and the hand-composited sheet is
    * exactly the unreproducible artifact `mount` exists to replace.
    *
    * An asset with a `source` needs no lockfile entry at all, so art
@@ -964,6 +1076,17 @@ var AssetSchema = z.object({
   sourceByStyle: z.record(z.string().min(1)).default({}),
   /** Controlled generation derived from another asset in the same style. */
   revision: RevisionSchema.optional(),
+  /**
+   * The provider's own id for art that already exists on the account, so
+   * `adopt` can map it without matching bytes: an object id, a character
+   * id, or `<character id>#<animation group id>` for a character animation.
+   * Not part of the spec's identity.
+   */
+  remoteId: z.string().min(1).optional(),
+  /** `character` styles: this asset is a pose or outfit of another character asset. */
+  state: CharacterStateSchema.optional(),
+  /** `character` styles: this asset is a loop of another character asset in one direction. */
+  animation: CharacterAnimationSchema.optional(),
   /**
    * Generated output role to place in `cell` when this asset expands to
    * several files. Omit for ordinary single-output assets. A structural set
@@ -1003,6 +1126,14 @@ var AssetSchema = z.object({
       path: ["revision"]
     });
   }
+  const shapes = [asset.revision && "revision", asset.state && "state", asset.animation && "animation"].filter(Boolean);
+  if (shapes.length > 1) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `${shapes.join(" and ")} are mutually exclusive`,
+      path: [shapes[1]]
+    });
+  }
 });
 var DEFAULT_HISTORY_LIMIT = 5;
 var HistoryLimitSchema = z.number().int().min(0).max(100);
@@ -1134,8 +1265,8 @@ var LockEntrySchema = z.object({
   ).default([]),
   /**
    * Files this entry produced. A plain object generates one; asset kinds that
-   * expand into many — an animated character is ~35 spritesheets plus an engine
-   * resource — need the list, which is why v1's single `file` became this.
+   * expand into many, an animated character being ~35 spritesheets plus an engine
+   * resource, need the list, which is why v1's single `file` became this.
    *
    * `role` labels non-primary artifacts (e.g. "portrait", "spriteframes") so a
    * consumer can find the one it wants without pattern-matching on paths.
@@ -1700,7 +1831,7 @@ function paletteSwatch(hexes, size = 64) {
 }
 function parseHex(hex2) {
   const m = /^#?([0-9a-f]{6})$/i.exec(hex2.trim());
-  if (!m) throw new Error(`invalid hex colour "${hex2}" \u2014 expected #rrggbb`);
+  if (!m) throw new Error(`invalid hex colour "${hex2}"; expected #rrggbb`);
   const n = parseInt(m[1], 16);
   return { r: n >> 16 & 255, g: n >> 8 & 255, b: n & 255 };
 }
@@ -3224,9 +3355,28 @@ function applyPostprocess(bytes, mediaType, record) {
 import { existsSync as existsSync4 } from "fs";
 import path7 from "path";
 async function inspectRevisionReadiness(spec, lock) {
+  if (spec.character?.parentSpec) return inspectCharacterParent(spec, lock, /* @__PURE__ */ new Set());
   if (!spec.revision) return null;
   return inspectRevision(spec, lock, /* @__PURE__ */ new Set());
 }
+async function inspectCharacterParent(spec, lock, seen) {
+  const character = spec.character;
+  const parentSpec = character.parentSpec;
+  const label = `${character.kind} parent ${spec.styleId}/${character.parentAssetId}`;
+  const dependency = await inspectParent(parentSpec, lock, seen);
+  if (!dependency.ready) return { ready: false, reason: `${label} is not ready: ${dependency.reason}` };
+  if (!character.parentSha256 || !character.parentFile || !existsSync4(character.parentFile)) {
+    return { ready: false, reason: `${label} has no generated south-facing file yet` };
+  }
+  if (await sha256File(character.parentFile) !== character.parentSha256) {
+    return { ready: false, reason: `${label} changed after the manifest was resolved` };
+  }
+  const parentEntry = lock.entries[lockKey(parentSpec.styleId, parentSpec.assetId)];
+  if (!parentEntry?.objectId) {
+    return { ready: false, reason: `${label} has no PixelLab character id recorded` };
+  }
+  return { ready: true, reason: `${label} is current` };
+}
 async function inspectRevision(spec, lock, seen) {
   const revision = spec.revision;
   if (!revision) return { ready: true, reason: "asset has no revision inputs" };
@@ -3266,6 +3416,10 @@ async function inspectParent(spec, lock, seen) {
     const inputs = await inspectRevision(spec, lock, nextSeen);
     if (!inputs.ready) return inputs;
   }
+  if (spec.character?.parentSpec) {
+    const inputs = await inspectCharacterParent(spec, lock, nextSeen);
+    if (!inputs.ready) return inputs;
+  }
   if (spec.quality) {
     const quality = await inspectQualityProfile(spec, lock);
     return quality?.state === "approved" ? { ready: true, reason: "approved quality output is current" } : {
@@ -3400,7 +3554,19 @@ async function buildPlan(specs, lock, opts = {}) {
     const quality = await inspectQualityProfile(spec, lock);
     items.push({ spec, key, state, reason, ...quality ? { quality } : {} });
   }
-  const actionable = items.filter((i) => i.state === "missing" || i.state === "stale" || i.state === "failed");
+  const isActionable = (i) => i.state === "missing" || i.state === "stale" || i.state === "failed";
+  const actionableKeys = new Set(items.filter(isActionable).map((i) => i.key));
+  for (const item of items) {
+    if (!isActionable(item)) continue;
+    const parent = item.spec.revision?.sourceSpec ?? item.spec.character?.parentSpec;
+    if (!parent) continue;
+    const parentKey = lockKey(parent.styleId, parent.assetId);
+    if (actionableKeys.has(parentKey)) {
+      item.state = "blocked";
+      item.reason = `parent ${parentKey} is being generated in this run; this follows in the next wave`;
+    }
+  }
+  const actionable = items.filter(isActionable);
   const groupsByProvider = /* @__PURE__ */ new Map();
   for (const item of actionable) {
     const provider = item.spec.provider;
@@ -3476,7 +3642,7 @@ function announceGalleryReady(url, count, stdout = process.stdout, stderr = proc
   gallery of ${count} generation${count === 1 ? "" : "s"}: ${url}
 ` + (notes.length ? `  (${notes.join("; ")}; Ctrl+C to stop)
 
-` : "  (read-only \u2014 add --edit to change prompts or edit sprites, --budget <n> to generate; Ctrl+C to stop)\n\n")
+` : "  (read-only; add --edit to change prompts or edit sprites, --budget <n> to generate; Ctrl+C to stop)\n\n")
   );
 }
 function printPlan(plan) {
@@ -3509,7 +3675,7 @@ function printPlan(plan) {
   if (plan.actionable.length) {
     for (const group of plan.groups) {
       log(
-        `  ${group.provider}: ${group.actionable.length} asset(s) \u2014 ${formatCost(group.costUnit, group.cost)}, ${group.candidates} candidate/output image(s)`
+        `  ${group.provider}: ${group.actionable.length} asset(s), ${formatCost(group.costUnit, group.cost)}, ${group.candidates} candidate/output image(s)`
       );
     }
   } else {
@@ -3531,7 +3697,7 @@ function printResumeActions(specs, lock) {
     const shown = action.keys.slice(0, 3).join(", ");
     const more = action.keys.length > 3 ? `, +${action.keys.length - 3} more` : "";
     log(
-      `  next: pixelkiln ${action.command} \u2014 ${action.keys.length} asset${action.keys.length === 1 ? "" : "s"} (${shown}${more})`
+      `  next: pixelkiln ${action.command} for ${action.keys.length} asset${action.keys.length === 1 ? "" : "s"} (${shown}${more})`
     );
   }
   return actions.length;
@@ -3552,8 +3718,8 @@ async function confirm(question, auto) {
 }
 
 // src/cli/commands/account.ts
-import path20 from "path";
-import { existsSync as existsSync15 } from "fs";
+import path21 from "path";
+import { existsSync as existsSync16 } from "fs";
 
 // src/env.ts
 import { readFileSync, existsSync as existsSync6 } from "fs";
@@ -4605,6 +4771,60 @@ var MapObjectSchema = z2.object({
 var ObjectListSchema = z2.object({ objects: z2.array(PixelLabObjectSchema), total: z2.number().int().min(0) }).passthrough();
 var PixfluxResponseSchema = z2.object({ image: z2.object({ base64: z2.string().min(1) }).passthrough(), usage: z2.unknown().optional() }).passthrough();
 var SelectFramesSchema = z2.object({ created_object_ids: z2.array(z2.string()) }).passthrough();
+var UsageSchema = z2.object({
+  type: z2.string().optional(),
+  usd: z2.number().nullable().optional(),
+  generations: z2.number().nullable().optional()
+}).passthrough().nullable().optional();
+var CharacterSubmitSchema = z2.object({
+  background_job_id: z2.string().min(1),
+  character_id: z2.string().min(1),
+  status: z2.string().default("processing"),
+  usage: UsageSchema
+}).passthrough();
+var AnimateSubmitSchema = z2.object({
+  background_job_ids: z2.array(z2.string()),
+  directions: z2.array(z2.string()),
+  status: z2.string().default("processing"),
+  usage: UsageSchema
+}).passthrough();
+var CharacterAnimationDirectionSchema = z2.object({
+  direction: z2.string(),
+  frame_count: z2.number().int().min(0),
+  frames: z2.array(z2.string())
+}).passthrough();
+var CharacterAnimationSchema2 = z2.object({
+  animation_type: z2.string(),
+  display_name: z2.string().nullable().optional(),
+  animation_group_id: z2.string().nullable().optional(),
+  directions: z2.array(CharacterAnimationDirectionSchema)
+}).passthrough();
+var CharacterSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().default(""),
+  state_name: z2.string().nullable().optional(),
+  prompt: z2.string().default(""),
+  size: z2.object({ width: z2.number().int().positive(), height: z2.number().int().positive() }),
+  directions: z2.number().int(),
+  created_at: z2.string(),
+  updated_at: z2.string().nullable().optional(),
+  animation_count: z2.number().int().default(0),
+  template_id: z2.string().default("mannequin"),
+  view: z2.string().nullable().optional(),
+  status: z2.string().default("completed"),
+  rotation_urls: z2.record(z2.string().nullable()).nullable().optional(),
+  tags: z2.array(z2.string()).default([]),
+  group_id: z2.string().nullable().optional(),
+  animations: z2.array(CharacterAnimationSchema2).default([]),
+  preview_url: z2.string().nullable().optional()
+}).passthrough();
+var CharacterListSchema = z2.object({ characters: z2.array(CharacterSchema), total: z2.number().int().min(0) }).passthrough();
+var BackgroundJobSchema = z2.object({
+  id: z2.string(),
+  status: z2.string(),
+  last_response: z2.record(z2.unknown()).nullable().optional()
+}).passthrough();
+var DeleteAnimationsSchema = z2.object({ success: z2.boolean(), deleted_count: z2.number().int().default(0), error: z2.string().nullable().optional() }).passthrough();
 function validateResponse(schema, raw, operation) {
   const parsed = schema.safeParse(raw);
   if (parsed.success) return parsed.data;
@@ -4628,9 +4848,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path43, init) {
+  async request(path44, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path43}`, {
+    const res = await this.http(`${BASE}${path44}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -4640,13 +4860,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path43} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path44} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path43} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path44} returned invalid JSON`);
     }
   }
   async balance() {
@@ -4663,7 +4883,7 @@ var PixelLabClient = class {
    *
    * `size` and `styleImages` are mutually exclusive at the API level: when style
    * images are supplied the largest one dictates the output size. So style
-   * references must already be at the target resolution — a 128px reference
+   * references must already be at the target resolution; a 128px reference
    * silently produces 128px output and a different candidate count.
    */
   async create1Direction(args) {
@@ -4687,7 +4907,7 @@ var PixelLabClient = class {
     return parsed;
   }
   /**
-   * Arbitrary width x height. Returns a single result — no selection step.
+   * Arbitrary width x height. Returns a single result, no selection step.
    *
    * These AUTO-DELETE AFTER 8 HOURS, so `fetch` must run in the same session as
    * `submit`. The pipeline warns when a map-object entry is older than that.
@@ -4709,12 +4929,12 @@ var PixelLabClient = class {
     );
   }
   /**
-   * Draws a whole tile set in one call — many variations, or a connectable
+   * Draws a whole tile set in one call: many variations, or a connectable
    * set when `tileFeature` is given.
    *
    * `styleImages` here is NOT the shape `create-1-direction-object` uses.
-   * TilesProStyleImage is flat — `{base64, width, height}`, all three
-   * required — where 1dir wants `{type, base64, format}`. Confirmed against
+   * TilesProStyleImage is flat, `{base64, width, height}` with all three
+   * required, where 1dir wants `{type, base64, format}`. Confirmed against
    * the OpenAPI schema; sending 1dir's shape is rejected as an extra field.
    *
    * Passing style images also makes the API ignore `tileType` and `tileView`
@@ -4735,7 +4955,7 @@ var PixelLabClient = class {
       "create tiles"
     );
   }
-  /** Throws PixelLabError(423) while the set is still drawing — see TilesPro. */
+  /** Throws PixelLabError(423) while the set is still drawing; see TilesPro. */
   async getTilesPro(tileId) {
     return validateResponse(
       TilesProSchema,
@@ -4745,7 +4965,7 @@ var PixelLabClient = class {
   }
   /**
    * Synchronous single-image generation. Returns the PNG inline rather than a
-   * job id, and is the only endpoint that honours a forced palette —
+   * job id, and is the only endpoint that honours a forced palette;
    * `color_image` on /map-objects returns a 500 whatever the payload shape.
    */
   async createImagePixflux(args) {
@@ -4803,7 +5023,7 @@ var PixelLabClient = class {
   /**
    * Promotes chosen candidates to standalone objects, each with its own id.
    * The review parent survives until nothing is left in it, so the returned
-   * `created_object_ids` — not the parent id — is what should be recorded.
+   * `created_object_ids`, not the parent id, is what should be recorded.
    */
   async selectFrames(objectId, indices, commonTag) {
     const raw = await this.request(`/objects/${objectId}/select-frames`, {
@@ -4819,10 +5039,140 @@ var PixelLabClient = class {
   dismissReview(objectId) {
     return this.request(`/objects/${objectId}/dismiss-review`, { method: "POST" });
   }
-  /** Free and synchronous. Replaces the full tag set — include tags you want to keep. */
+  /** Free and synchronous. Replaces the full tag set, so include tags you want to keep. */
   setTags(objectId, tags) {
     return this.request(`/objects/${objectId}/tags`, { method: "PATCH", body: JSON.stringify({ tags }) });
   }
+  /**
+   * A base character. Standard mode picks the 4- or 8-direction template
+   * endpoint; v3 and pro have their own and always draw 8. Every one answers
+   * at once with the character id and a background job.
+   */
+  async createCharacter(args) {
+    const imageSize = { width: args.size, height: args.size };
+    const palette = args.paletteSwatchBase64 ? { color_image: { type: "base64", base64: args.paletteSwatchBase64, format: "png" }, force_colors: true } : {};
+    let path44;
+    let body;
+    if (args.mode === "v3") {
+      path44 = "/create-character-v3";
+      body = {
+        description: args.description,
+        image_size: imageSize,
+        template_id: args.template,
+        no_background: args.noBackground ?? true,
+        ...args.view ? { view: args.view } : {},
+        ...args.outline ? { outline: args.outline } : {},
+        ...args.detail ? { detail: args.detail } : {},
+        ...args.seed != null ? { seed: args.seed } : {}
+      };
+    } else if (args.mode === "pro") {
+      path44 = "/create-character-pro";
+      body = {
+        description: args.description,
+        image_size: imageSize,
+        template_id: args.template,
+        no_background: args.noBackground ?? true,
+        ...args.view ? { view: args.view } : {},
+        ...args.seed != null ? { seed: args.seed } : {}
+      };
+    } else {
+      path44 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      body = {
+        description: args.description,
+        image_size: imageSize,
+        template_id: args.template,
+        ...args.view ? { view: args.view } : {},
+        ...args.outline ? { outline: args.outline } : {},
+        ...args.shading ? { shading: args.shading } : {},
+        ...args.detail ? { detail: args.detail } : {},
+        ...args.seed != null ? { seed: args.seed } : {},
+        ...palette
+      };
+    }
+    const raw = await this.request(path44, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path44.slice(1));
+  }
+  /** A text edit of an existing character, applied to every direction and stored as a sibling. */
+  async createCharacterState(args) {
+    const raw = await this.request("/create-character-state", {
+      method: "POST",
+      body: JSON.stringify({
+        character_id: args.characterId,
+        edit_description: args.editDescription,
+        no_background: args.noBackground ?? true,
+        use_color_palette_from_reference: args.paletteFromReference ?? false,
+        ...args.stateName ? { state_name: args.stateName } : {},
+        ...args.canvas ? { override_frame_size: args.canvas } : {},
+        ...args.seed != null ? { seed: args.seed } : {}
+      })
+    });
+    return validateResponse(CharacterSubmitSchema, raw, "create-character-state");
+  }
+  /**
+   * One animation of one character. Template mode costs a generation per
+   * direction and fixes the frame count; v3 draws `frameCount` frames from
+   * the action text; pro is the sequential engine. One job per direction.
+   */
+  async animateCharacter(args) {
+    const raw = await this.request("/animate-character", {
+      method: "POST",
+      body: JSON.stringify({
+        character_id: args.characterId,
+        animation_name: args.animationName,
+        mode: args.mode,
+        directions: args.directions,
+        ...args.template ? { template_animation_id: args.template } : {},
+        ...args.actionDescription ? { action_description: args.actionDescription } : {},
+        ...args.mode === "v3" && args.frameCount ? { frame_count: args.frameCount } : {},
+        ...args.mode === "v3" && args.keepFirstFrame === false ? { keep_first_frame: false } : {},
+        ...args.seed != null ? { seed: args.seed } : {}
+      })
+    });
+    return validateResponse(AnimateSubmitSchema, raw, "animate-character");
+  }
+  async getCharacter(characterId) {
+    const raw = await this.request(`/characters/${encodeURIComponent(characterId)}`);
+    return validateResponse(CharacterSchema, raw, "characters/{id}");
+  }
+  async listCharacters(limit = 100, offset = 0) {
+    const raw = await this.request(`/characters?limit=${limit}&offset=${offset}`);
+    return validateResponse(CharacterListSchema, raw, "characters");
+  }
+  async *iterateCharacters(pageSize = 100) {
+    let offset = 0;
+    for (; ; ) {
+      const page = await this.listCharacters(pageSize, offset);
+      for (const character of page.characters) yield character;
+      offset += page.characters.length;
+      if (page.characters.length === 0 || offset >= page.total) return;
+    }
+  }
+  async getBackgroundJob(jobId) {
+    const raw = await this.request(`/background-jobs/${encodeURIComponent(jobId)}`);
+    return validateResponse(BackgroundJobSchema, raw, "background-jobs/{id}");
+  }
+  /** Remove one animation group from a character, or one direction of it. */
+  async deleteCharacterAnimations(characterId, selector, direction) {
+    const query = new URLSearchParams(
+      "animationGroupId" in selector ? { animation_group_id: selector.animationGroupId } : { animation_type: selector.animationType }
+    );
+    if (direction) query.set("direction", direction);
+    const raw = await this.request(
+      `/characters/${encodeURIComponent(characterId)}/animations?${query.toString()}`,
+      { method: "DELETE" }
+    );
+    return validateResponse(DeleteAnimationsSchema, raw, "characters/{id}/animations");
+  }
+  /** Irreversible: the character, its states are separate records, and its animations. */
+  deleteCharacter(characterId) {
+    return this.request(`/characters/${encodeURIComponent(characterId)}`, { method: "DELETE" });
+  }
+  setCharacterTags(characterId, tags) {
+    return this.request(`/characters/${encodeURIComponent(characterId)}/tags`, {
+      method: "PATCH",
+      body: JSON.stringify({ tags })
+    });
+  }
   /** Storage URLs are public; no auth header, and sending one can break the CDN request. */
   async download(url) {
     const res = await this.http(url);
@@ -4860,6 +5210,39 @@ function pixelLabObjectUrl(generator, objectId) {
   }
   return null;
 }
+function characterCost(spec) {
+  const character = spec.character;
+  if (!character) return generationCost(spec.width, spec.height, "1dir");
+  const px = spec.width * spec.height;
+  if (character.kind === "animation") {
+    const animation = character.animation;
+    if (animation.mode === "template") return 1;
+    if (animation.mode === "v3") return Math.max(1, Math.ceil(px * animation.frames / 65536));
+    return generationCost(spec.width, spec.height, "1dir");
+  }
+  if (character.kind === "state") return generationCost(spec.width, spec.height, "1dir");
+  if (character.mode === "standard") return 1;
+  if (character.mode === "v3") return 1 + Math.max(1, Math.ceil(px * 8 / 65536));
+  return generationCost(spec.width, spec.height, "1dir");
+}
+function characterAnimationName(spec) {
+  return `pixelkiln:${spec.styleId}/${spec.assetId}`;
+}
+var CHARACTER_TEMPLATES = ["mannequin", "bear", "cat", "dog", "horse", "lion"];
+function encodeAnimationJob(job) {
+  return `character-animation:${Buffer.from(JSON.stringify(job)).toString("base64url")}`;
+}
+function decodeAnimationJob(jobId) {
+  if (!jobId.startsWith("character-animation:")) return null;
+  try {
+    const value = JSON.parse(Buffer.from(jobId.slice("character-animation:".length), "base64url").toString("utf8"));
+    if (typeof value?.characterId === "string" && typeof value.name === "string" && typeof value.direction === "string") {
+      return { characterId: value.characterId, name: value.name, direction: value.direction, jobIds: Array.isArray(value.jobIds) ? value.jobIds : [] };
+    }
+  } catch {
+  }
+  return null;
+}
 var PixelLabProvider = class _PixelLabProvider {
   constructor(client2) {
     this.client = client2;
@@ -4878,11 +5261,11 @@ var PixelLabProvider = class _PixelLabProvider {
     return new _PixelLabProvider(new PixelLabClient("download-only"));
   }
   supports(generator) {
-    return generator === "1dir" || generator === "map" || generator === "pixflux" || generator === "tiles";
+    return generator === "1dir" || generator === "map" || generator === "pixflux" || generator === "tiles" || generator === "character";
   }
   /** PixelLab's own constraints: submissions must be >2s apart, and
    *  background jobs in flight are capped by subscription tier (Tier 1=8,
-   *  Tier 2=10, Tier 3=20) — 8 is the safe floor across every tier. */
+   *  Tier 2=10, Tier 3=20); 8 is the safe floor across every tier. */
   rateLimit() {
     return { spacingMs: 2500, maxInFlight: 8 };
   }
@@ -4903,6 +5286,9 @@ var PixelLabProvider = class _PixelLabProvider {
     if (spec.generator === "tiles") {
       return { unit: "generations", amount: spec.cost, candidates: spec.candidates };
     }
+    if (spec.generator === "character") {
+      return { unit: "generations", amount: characterCost(spec), candidates: 1 };
+    }
     return {
       unit: "generations",
       amount: generationCost(spec.width, spec.height, spec.generator),
@@ -4935,7 +5321,8 @@ var PixelLabProvider = class _PixelLabProvider {
         "high detail"
       ]);
     }
-    if ((spec.generator === "map" || spec.generator === "pixflux") && styleImages.length) {
+    if (spec.generator === "character") this.validateCharacter(spec);
+    if ((spec.generator === "map" || spec.generator === "pixflux" || spec.generator === "character") && styleImages.length) {
       throw new Error(`PixelLab ${spec.generator} does not support style images`);
     }
     for (const image of styleImages) {
@@ -4951,8 +5338,198 @@ var PixelLabProvider = class _PixelLabProvider {
       );
     }
   }
-  async submit(spec, styleImages) {
+  validateCharacter(spec) {
+    const character = spec.character;
+    if (!character) throw new Error(`${spec.styleId}/${spec.assetId} has no character shape`);
+    const maxSize = character.mode === "v3" ? 256 : 128;
+    if (spec.width < 16 || spec.height < 16 || spec.width > maxSize || spec.height > maxSize) {
+      throw new Error(`PixelLab ${character.mode} characters must be between 16 and ${maxSize} pixels`);
+    }
+    if (!CHARACTER_TEMPLATES.includes(character.template)) {
+      throw new Error(`PixelLab character template must be one of: ${CHARACTER_TEMPLATES.join(", ")}`);
+    }
+    const views = character.mode === "standard" ? ["low top-down", "high top-down", "side", "perspective", "oblique"] : ["low top-down", "high top-down", "side"];
+    if (!views.includes(spec.view)) {
+      throw new Error(`PixelLab ${character.mode} character view must be one of: ${views.join(", ")}`);
+    }
+    if (spec.view === "oblique" && character.directions !== 4) {
+      throw new Error("PixelLab oblique characters are 4-direction only");
+    }
+    if (character.kind !== "base" && !character.parentAssetId) {
+      throw new Error(`${spec.styleId}/${spec.assetId} is a ${character.kind} with no parent`);
+    }
+    if (character.animation) {
+      const allowed = character.directions === 4 ? CHARACTER_DIRECTIONS_4 : CHARACTER_DIRECTIONS_8;
+      if (!allowed.includes(character.animation.direction)) {
+        throw new Error(
+          `${spec.styleId}/${spec.assetId} animates "${character.animation.direction}", but its character has ${character.directions} directions: ${allowed.join(", ")}`
+        );
+      }
+      if (character.animation.mode !== "template" && !spec.prompt.trim()) {
+        throw new Error(`${spec.styleId}/${spec.assetId} needs a prompt describing the motion, or a template`);
+      }
+    }
+  }
+  /**
+   * A base is one request that answers with the character id; a state is
+   * the same with the parent's id; an animation names itself after the
+   * asset so a later run can find it, and clears its own earlier take for
+   * that direction first, since PixelLab skips a direction that exists.
+   */
+  async submitCharacter(spec, context) {
+    const character = spec.character;
+    if (character.kind === "base") {
+      const swatch = spec.palette.length && character.mode === "standard" ? paletteSwatch(spec.palette).toString("base64") : void 0;
+      const res2 = await this.client.createCharacter({
+        mode: character.mode,
+        description: spec.prompt,
+        size: spec.width,
+        directions: character.directions,
+        view: spec.view,
+        template: character.template,
+        outline: spec.outline,
+        shading: spec.shading,
+        detail: spec.detail,
+        seed: spec.seed,
+        noBackground: spec.noBackground,
+        paletteSwatchBase64: swatch
+      });
+      return { jobId: res2.character_id, metadata: { character: { kind: "base", characterId: res2.character_id, mode: character.mode, directions: character.directions, backgroundJobId: res2.background_job_id } } };
+    }
+    const parentId = context?.parentObjectId;
+    if (!parentId) {
+      throw new Error(
+        `${spec.styleId}/${spec.assetId} is a ${character.kind} of ${character.parentAssetId}, which has no PixelLab character id in the lockfile yet; generate the parent first`
+      );
+    }
+    if (character.kind === "state") {
+      const res2 = await this.client.createCharacterState({
+        characterId: parentId,
+        editDescription: spec.prompt,
+        stateName: spec.assetId.slice(0, 50),
+        paletteFromReference: character.state?.paletteFromReference,
+        canvas: character.state?.canvas,
+        seed: spec.seed,
+        noBackground: spec.noBackground
+      });
+      return { jobId: res2.character_id, metadata: { character: { kind: "state", characterId: res2.character_id, parentCharacterId: parentId, mode: character.mode, directions: character.directions, backgroundJobId: res2.background_job_id } } };
+    }
+    const animation = character.animation;
+    const name = characterAnimationName(spec);
+    const replaced = context?.replacedMetadata?.character ?? {};
+    const existing = await this.client.getCharacter(parentId);
+    for (const group of existing.animations) {
+      const ours = group.animation_group_id && (group.animation_group_id === replaced.animationGroupId || group.display_name === name || replaced.animationId && group.directions.some((d) => d.frames.some((url) => url.includes(`/animations/${replaced.animationId}/`))));
+      if (!ours || !group.animation_group_id) continue;
+      if (group.directions.some((d) => d.direction === animation.direction)) {
+        await this.client.deleteCharacterAnimations(parentId, { animationGroupId: group.animation_group_id }, animation.direction);
+      }
+    }
+    const res = await this.client.animateCharacter({
+      characterId: parentId,
+      animationName: name,
+      actionDescription: spec.prompt.trim() || void 0,
+      template: animation.template,
+      mode: animation.mode,
+      frameCount: animation.frames,
+      keepFirstFrame: animation.keepFirstFrame,
+      directions: [animation.direction],
+      seed: spec.seed
+    });
+    const job = { characterId: parentId, name, direction: animation.direction, jobIds: res.background_job_ids };
+    return {
+      jobId: encodeAnimationJob(job),
+      metadata: { character: { kind: "animation", characterId: parentId, animationName: name, direction: animation.direction, mode: animation.mode, backgroundJobIds: res.background_job_ids } }
+    };
+  }
+  async pollCharacter(jobId, context) {
+    const animation = decodeAnimationJob(jobId);
+    if (animation) return this.pollCharacterAnimation(animation, context);
+    const character = await this.client.getCharacter(jobId);
+    if (character.status === "failed") return { status: "failed", error: "character generation failed upstream" };
+    if (character.status !== "completed" || !character.rotation_urls) return { status: "processing" };
+    const order = character.directions === 4 ? CHARACTER_DIRECTIONS_4 : CHARACTER_DIRECTIONS_8;
+    const sources = [];
+    for (const direction of order) {
+      const url = character.rotation_urls[direction];
+      if (url) sources.push({ url, role: direction });
+    }
+    if (!sources.length) return { status: "failed", error: "character completed with no rotation images" };
+    return {
+      status: "ready",
+      objectId: character.id,
+      sourceUrl: sources[0].url,
+      sources,
+      metadata: {
+        character: {
+          characterId: character.id,
+          groupId: character.group_id ?? null,
+          name: character.name,
+          stateName: character.state_name ?? null,
+          directions: character.directions,
+          size: character.size,
+          updatedAt: character.updated_at ?? null
+        }
+      }
+    };
+  }
+  /**
+   * The background job is the authoritative record of one direction: it
+   * completes with the frame URLs, the animation id, and the direction, and
+   * it reports a failure. The character's own animation list is the
+   * fallback once PixelLab has cleaned the job up, and the place the group
+   * id (what a later delete needs) is read from.
+   */
+  async pollCharacterAnimation(job, context) {
+    const fps = context?.spec?.character?.animation?.fps ?? 8;
+    const review = (frames, animationId, groupId) => ({
+      status: "review-set",
+      objectId: `${job.characterId}#${groupId ?? animationId ?? job.name}`,
+      frameUrls: frames,
+      sources: frames.map((url, index) => ({ url, role: `frame-${String(index).padStart(2, "0")}` })),
+      fps,
+      metadata: {
+        frameSet: { fps, count: frames.length },
+        character: {
+          kind: "animation",
+          characterId: job.characterId,
+          animationId,
+          animationGroupId: groupId,
+          animationName: job.name,
+          direction: job.direction
+        }
+      }
+    });
+    let cleanedUp = job.jobIds.length === 0;
+    for (const id of job.jobIds) {
+      const status = await this.client.getBackgroundJob(id).catch((err) => {
+        if (err instanceof PixelLabError && err.status === 404) return null;
+        throw err;
+      });
+      if (!status) {
+        cleanedUp = true;
+        continue;
+      }
+      if (status.status === "failed") return { status: "failed", error: "animation generation failed upstream" };
+      if (status.status !== "completed") return { status: "processing" };
+      const done = status.last_response ?? {};
+      const frames = done.storage_urls?.frames;
+      const animationId = typeof done.animation_id === "string" ? done.animation_id : null;
+      if (Array.isArray(frames) && frames.length && frames.every((f) => typeof f === "string")) {
+        const character2 = await this.client.getCharacter(job.characterId);
+        const group = findAnimation(character2, job.name, job.direction, animationId);
+        return review(frames, animationId, group?.groupId ?? null);
+      }
+    }
+    const recorded = context?.metadata?.character?.animationId ?? null;
+    const character = await this.client.getCharacter(job.characterId);
+    const found = findAnimation(character, job.name, job.direction, recorded);
+    if (found) return review(found.frames, found.animationId, found.groupId);
+    return cleanedUp ? { status: "failed", error: `animation job is gone upstream and no "${job.name}" ${job.direction} animation exists on the character` } : { status: "processing" };
+  }
+  async submit(spec, styleImages, context) {
     this.validate(spec, styleImages);
+    if (spec.generator === "character") return this.submitCharacter(spec, context);
     if (spec.generator === "pixflux") {
       const swatch = spec.palette.length ? paletteSwatch(spec.palette).toString("base64") : void 0;
       const { png } = await this.client.createImagePixflux({
@@ -5017,6 +5594,7 @@ var PixelLabProvider = class _PixelLabProvider {
     }
     if (generator === "map") return this.pollMap(jobId);
     if (generator === "tiles") return this.pollTiles(jobId, Boolean(context?.tileFeature));
+    if (generator === "character") return this.pollCharacter(jobId, context);
     const obj = await this.client.getObject(jobId);
     if (obj.status === "review") {
       return { status: "review", candidateUrls: obj.frame_urls ?? [] };
@@ -5118,7 +5696,11 @@ var PixelLabProvider = class _PixelLabProvider {
     const b = await this.client.balance();
     return { unit: "generations", remaining: b.generations, total: b.total, plan: b.plan };
   }
-  async setTags(objectId, tags) {
+  async setTags(objectId, tags, generator) {
+    if (generator === "character") {
+      await this.client.setCharacterTags(objectId.split("#")[0], tags.slice(0, 20));
+      return;
+    }
     await this.client.setTags(objectId, tags.slice(0, 20));
   }
   async *list() {
@@ -5138,7 +5720,49 @@ var PixelLabProvider = class _PixelLabProvider {
   async delete(assetId) {
     await this.client.deleteObject(assetId);
   }
+  async *listCharacters() {
+    for await (const character of this.client.iterateCharacters(100)) {
+      yield remoteCharacter(character);
+    }
+  }
+  async getCharacter(id) {
+    const character = await this.client.getCharacter(id);
+    const order = character.directions === 4 ? CHARACTER_DIRECTIONS_4 : CHARACTER_DIRECTIONS_8;
+    const rotations = [];
+    for (const direction of order) {
+      const url = character.rotation_urls?.[direction];
+      if (url) rotations.push({ url, role: direction });
+    }
+    return {
+      ...remoteCharacter(character),
+      rotations,
+      animations: character.animations.flatMap((group) => group.directions.map((d) => ({
+        groupId: group.animation_group_id ?? null,
+        name: group.display_name ?? null,
+        type: group.animation_type,
+        direction: d.direction,
+        frames: d.frames
+      })))
+    };
+  }
 };
+function remoteCharacter(character) {
+  return {
+    id: character.id,
+    name: character.name,
+    stateName: character.state_name ?? null,
+    prompt: character.prompt,
+    groupId: character.group_id ?? null,
+    directions: character.directions,
+    width: character.size.width,
+    height: character.size.height,
+    createdAt: character.created_at,
+    previewUrl: character.preview_url ?? character.rotation_urls?.south ?? null,
+    tags: character.tags,
+    status: character.status,
+    animationCount: character.animation_count
+  };
+}
 function requirePixelLabOption(name, value, allowed) {
   if (value != null && !allowed.includes(value)) {
     throw new Error(`PixelLab map ${name} must be one of: ${allowed.join(", ")}`);
@@ -5151,6 +5775,18 @@ function firstUrl(urls) {
   if (!urls) return null;
   return Object.values(urls).find((u) => typeof u === "string") ?? null;
 }
+function findAnimation(character, name, direction, animationId) {
+  for (const group of character.animations) {
+    const match = group.directions.find((d) => d.direction === direction && d.frames.length > 0);
+    if (!match) continue;
+    const byName = group.display_name === name || group.animation_type === name;
+    const byId = animationId !== null && match.frames.some((url) => url.includes(`/animations/${animationId}/`));
+    if (!byName && !byId) continue;
+    const fromUrl = /\/animations\/([^/]+)\//.exec(match.frames[0])?.[1] ?? null;
+    return { frames: match.frames, groupId: group.animation_group_id ?? null, animationId: animationId ?? fromUrl };
+  }
+  return null;
+}
 
 // src/providers/retrodiffusion.ts
 var DEFAULT_BASE_URL2 = "https://api.retrodiffusion.ai/v1";
@@ -5200,9 +5836,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(path43, init = {}) {
+  async call(path44, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path43}`, {
+    const response = await this.request(`${this.baseUrl}${path44}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -6111,33 +6747,50 @@ ${issues}`);
         unknownReferences.push(`assets.${assetId}.revision.from: an asset cannot revise itself`);
       }
     }
+    for (const shape of ["state", "animation"]) {
+      const of = asset[shape]?.of;
+      if (!of) continue;
+      const parent = parsed.data.assets[of];
+      if (!parent) {
+        unknownReferences.push(`assets.${assetId}.${shape}.of: unknown asset "${of}"`);
+      } else if (of === assetId) {
+        unknownReferences.push(`assets.${assetId}.${shape}.of: an asset cannot be a ${shape} of itself`);
+      } else if (parent.animation) {
+        unknownReferences.push(`assets.${assetId}.${shape}.of: "${of}" is an animation and cannot be a parent`);
+      }
+    }
   }
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  const visitRevision = (assetId, chain) => {
+  const visitParents = (assetId, chain) => {
     if (visited.has(assetId)) return;
     if (visiting.has(assetId)) {
       const start = chain.indexOf(assetId);
+      const shape = parsed.data.assets[assetId]?.revision ? "revision" : parsed.data.assets[assetId]?.state ? "state" : "animation";
+      const field = shape === "revision" ? "revision.from" : `${shape}.of`;
       unknownReferences.push(
-        `assets.${assetId}.revision.from: revision cycle ${[...chain.slice(start), assetId].join(" -> ")}`
+        `assets.${assetId}.${field}: ${shape} cycle ${[...chain.slice(start), assetId].join(" -> ")}`
       );
       return;
     }
     visiting.add(assetId);
-    const parent = parsed.data.assets[assetId]?.revision?.from;
+    const parent = parentAssetId(parsed.data.assets[assetId]);
     if (parent && parent !== assetId && parsed.data.assets[parent]) {
-      visitRevision(parent, [...chain, assetId]);
+      visitParents(parent, [...chain, assetId]);
     }
     visiting.delete(assetId);
     visited.add(assetId);
   };
-  for (const assetId of Object.keys(parsed.data.assets)) visitRevision(assetId, []);
+  for (const assetId of Object.keys(parsed.data.assets)) visitParents(assetId, []);
   if (unknownReferences.length) {
     throw new ProjectError(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
   return { manifest: parsed.data, root: path12.dirname(abs), path: abs };
 }
+function parentAssetId(asset) {
+  return asset?.revision?.from ?? asset?.state?.of ?? asset?.animation?.of;
+}
 function formatManifestIssues(issues) {
   return issues.flatMap((issue) => {
     if (issue.code === "invalid_union") {
@@ -6225,10 +6878,10 @@ async function resolveSpecs(loaded, filter) {
   const requestedAssetIds = new Set(filter?.assets?.length ? filter.assets : Object.keys(manifest.assets));
   const resolutionAssetIds = new Set(requestedAssetIds);
   for (const assetId of [...requestedAssetIds]) {
-    let current = manifest.assets[assetId]?.revision?.from;
+    let current = parentAssetId(manifest.assets[assetId]);
     while (current && !resolutionAssetIds.has(current)) {
       resolutionAssetIds.add(current);
-      current = manifest.assets[current]?.revision?.from;
+      current = parentAssetId(manifest.assets[current]);
     }
   }
   const styleImageCache = /* @__PURE__ */ new Map();
@@ -6301,13 +6954,23 @@ async function resolveSpecs(loaded, filter) {
         width = styleImageDimensions.length ? Math.max(...styleImageDimensions.map((img) => img.width)) : style.tileSize ?? 32;
         height = styleImageDimensions.length ? Math.max(...styleImageDimensions.map((img) => img.height)) : style.tileSize ?? 32;
         size = Math.max(width, height);
+      } else if (generator === "character") {
+        size = asset.state?.canvas ? Math.max(asset.state.canvas.width, asset.state.canvas.height) : asset.size ?? style.size ?? 64;
+        width = asset.state?.canvas?.width ?? size;
+        height = asset.state?.canvas?.height ?? size;
       } else {
         width = asset.width ?? style.size ?? 64;
         height = asset.height ?? style.size ?? 64;
         size = Math.max(width, height);
       }
+      if ((asset.state || asset.animation) && generator !== "character") {
+        throw new Error(
+          `assets.${assetId}: ${asset.state ? "state" : "animation"} needs a character style; "${styleId}" generates ${generator}`
+        );
+      }
+      const characterKind = asset.animation ? "animation" : asset.state ? "state" : "base";
       const subject = asset.promptByStyle[styleId] ?? asset.prompt;
-      const prompt = [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
+      const prompt = generator === "character" && characterKind !== "base" ? subject.trim() : [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
       const relFile = asset.file ?? path12.join(asset.category ?? "", `${assetId}.png`);
       const outFile = path12.resolve(root, style.outDir, relFile);
       const qualityOutFile = style.quality ? path12.resolve(root, style.quality.outDir, pngPath(relFile)) : void 0;
@@ -6324,7 +6987,7 @@ async function resolveSpecs(loaded, filter) {
         width,
         height,
         size,
-        view: style.view ?? (generator === "1dir" ? "top-down" : "high top-down"),
+        view: style.view ?? (generator === "1dir" ? "top-down" : generator === "character" ? "low top-down" : "high top-down"),
         styleImagePaths: style.styleImages.map((s) => s.path),
         outline: style.outline,
         shading: style.shading,
@@ -6338,6 +7001,7 @@ async function resolveSpecs(loaded, filter) {
         tileView: generator === "tiles" ? style.tileView : void 0,
         tileFeature: generator === "tiles" ? style.tileFeature : void 0,
         outlineMode: generator === "tiles" ? style.outlineMode : void 0,
+        ...generator === "character" ? { character: resolveCharacterShape(asset, style, characterKind) } : {},
         cost: generator === "tiles" ? tilesCost(tileSize, tileVariations) : generationCost(width, height, generator),
         costUnit: "generations",
         candidates: generator === "tiles" ? tileVariations : generator === "1dir" ? candidateCount(size) : 1
@@ -6368,6 +7032,7 @@ async function resolveSpecs(loaded, filter) {
         } : {},
         tags,
         source: asset.sourceByStyle[styleId] ?? asset.source,
+        ...asset.remoteId ? { remoteId: asset.remoteId } : {},
         // Revision identity is attached after every dependency in this style
         // has a concrete output target. Finalization below computes the hash.
         specHash: ""
@@ -6384,6 +7049,22 @@ async function resolveSpecs(loaded, filter) {
       }
       if (finalized.has(assetId)) return resolved;
       const asset = manifest.assets[assetId];
+      const characterParent = asset.state?.of ?? asset.animation?.of;
+      if (resolved.character && characterParent) {
+        const parentSpec = await finalize(characterParent);
+        const parentDirections = parentSpec.character?.directions ?? 8;
+        const parentFile = memberPath(parentSpec.outFile, "south", 0, parentDirections, MediaType.PNG);
+        resolved.character = {
+          ...resolved.character,
+          parentAssetId: characterParent,
+          parentSpec,
+          parentFile,
+          parentSha256: existsSync8(parentFile) ? await sha256File(parentFile) : null,
+          // A state and its animations keep the engine and rotations of the base.
+          mode: resolved.character.kind === "base" ? resolved.character.mode : parentSpec.character?.mode ?? resolved.character.mode,
+          directions: resolved.character.kind === "base" ? resolved.character.directions : parentSpec.character?.directions ?? resolved.character.directions
+        };
+      }
       if (asset.revision) {
         if (!activeProvider.supportsRevision?.(asset.revision.mode)) {
           throw new Error(
@@ -6531,6 +7212,34 @@ function imageMetadata(buf) {
   }
   return null;
 }
+function resolveCharacterShape(asset, style, kind) {
+  const mode2 = style.mode ?? "standard";
+  const directions = mode2 === "standard" ? style.directions ?? 8 : 8;
+  const shape = {
+    kind,
+    mode: mode2,
+    directions,
+    template: style.template ?? "mannequin"
+  };
+  if (asset.state) {
+    shape.state = {
+      paletteFromReference: asset.state.paletteFromReference,
+      ...asset.state.canvas ? { canvas: asset.state.canvas } : {}
+    };
+  }
+  if (asset.animation) {
+    const animationMode = asset.animation.mode ?? (asset.animation.template ? "template" : "v3");
+    shape.animation = {
+      mode: animationMode,
+      ...asset.animation.template ? { template: asset.animation.template } : {},
+      direction: asset.animation.direction,
+      frames: asset.animation.frames ?? 8,
+      fps: asset.animation.fps,
+      keepFirstFrame: asset.animation.keepFirstFrame
+    };
+  }
+  return shape;
+}
 
 // src/pipeline/fetch.ts
 import { existsSync as existsSync9, readFileSync as readFileSync3 } from "fs";
@@ -6833,7 +7542,7 @@ async function pushTags(provider, specs, lock, opts = {}) {
     if (entry.generator === "pixflux") continue;
     if (!provider.setTags) return tagged;
     try {
-      await provider.setTags(entry.objectId, spec.tags);
+      await provider.setTags(entry.objectId, spec.tags, entry.generator);
       tagged++;
     } catch (err) {
       log2(`  tag failed ${key}: ${err instanceof Error ? err.message : String(err)}`);
@@ -6864,10 +7573,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path43) {
-  if (!existsSync10(path43)) return { version: 1, hashes: {} };
+async function loadCache(path44) {
+  if (!existsSync10(path44)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile7(path43, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile7(path44, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -6879,27 +7588,30 @@ async function loadCache(path43) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path43, cache) {
+async function saveCache(path44, 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 mkdir4(pathModule.dirname(pathModule.resolve(path43)), { recursive: true });
-  const tmp = `${path43}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir4(pathModule.dirname(pathModule.resolve(path44)), { recursive: true });
+  const tmp = `${path44}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile4(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename4(tmp, path43);
+    await rename4(tmp, path44);
   } finally {
     await rm5(tmp, { force: true });
   }
 }
-function pruneCache(cache, liveIds) {
+function pruneCache(cache, liveIds, namespace = "") {
   let removed = 0;
-  for (const id of Object.keys(cache.hashes)) {
+  for (const key of Object.keys(cache.hashes)) {
+    const owned = namespace ? key.startsWith(namespace) : !key.includes(":");
+    if (!owned) continue;
+    const id = namespace ? key.slice(namespace.length) : key;
     if (!liveIds.has(id)) {
-      delete cache.hashes[id];
+      delete cache.hashes[key];
       removed++;
     }
   }
@@ -7033,7 +7745,7 @@ async function tagAdopted(provider, specs, lock, opts = {}) {
     if (!spec || !entry.objectId) continue;
     if (!provider.setTags) return count;
     try {
-      await provider.setTags(entry.objectId, spec.tags);
+      await provider.setTags(entry.objectId, spec.tags, entry.generator);
       count++;
     } catch (err) {
       log2(`  tag failed ${key}: ${err instanceof Error ? err.message : String(err)}`);
@@ -7077,20 +7789,272 @@ function formatUnmatchedRemote(objects, limit = 15) {
   return lines.join("\n");
 }
 
-// src/pipeline/salvage.ts
-import { readFile as readFile9 } from "fs/promises";
+// src/pipeline/adopt-characters.ts
 import { existsSync as existsSync12 } from "fs";
+import { mkdir as mkdir5, readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
 import path15 from "path";
+async function adoptCharacters(provider, specs, lock, lockPath, opts) {
+  const log2 = opts.onProgress ?? (() => {
+  });
+  const result = { scanned: 0, matched: 0, unmatched: [], remaining: [], written: [], differing: [] };
+  if (!provider.listCharacters || !provider.getCharacter) return result;
+  const wanted = specs.filter((spec) => spec.character);
+  if (!wanted.length) return result;
+  const remote = [];
+  for await (const character of provider.listCharacters()) remote.push(character);
+  result.scanned = remote.length;
+  log2(`  found ${remote.length} character(s) on the account`);
+  const cachePath = cachePathFor(lockPath);
+  const cache = opts.noCache ? { version: 1, hashes: {} } : await loadCache(cachePath);
+  const details = /* @__PURE__ */ new Map();
+  const detail = async (id) => {
+    let known = details.get(id);
+    if (!known) {
+      known = await provider.getCharacter(id);
+      details.set(id, known);
+    }
+    return known;
+  };
+  const bytesOf = /* @__PURE__ */ new Map();
+  const download = async (url) => {
+    let bytes = bytesOf.get(url);
+    if (!bytes) {
+      bytes = await provider.download(url);
+      decodePng(bytes);
+      bytesOf.set(url, bytes);
+    }
+    return bytes;
+  };
+  const southHash = async (character) => {
+    const cached = cache.hashes[`character:${character.id}`];
+    if (cached) return cached;
+    if (!character.previewUrl || character.status !== "completed") return null;
+    try {
+      const hash = sha256(await download(character.previewUrl));
+      cache.hashes[`character:${character.id}`] = hash;
+      return hash;
+    } catch {
+      return null;
+    }
+  };
+  const materialize = async (spec, sources) => {
+    const outputs = [];
+    for (const [index, source] of sources.entries()) {
+      const bytes = await download(source.url);
+      const hash = sha256(bytes);
+      const file = expectedOutputPath(spec, source.role, index, sources.length);
+      if (existsSync12(file)) {
+        if (sha256(await readFile9(file)) !== hash) result.differing.push(path15.relative(process.cwd(), file));
+      } else {
+        await mkdir5(path15.dirname(file), { recursive: true });
+        await writeFile6(file, bytes);
+        result.written.push(path15.relative(process.cwd(), file));
+      }
+      outputs.push({ path: portableOutputPath(file, spec.root), sha256: hash, ...source.role ? { role: source.role } : {} });
+    }
+    return outputs;
+  };
+  const claimed = /* @__PURE__ */ new Set();
+  for (const entry of Object.values(lock.entries)) {
+    if (entry.provider === provider.id && entry.generator === "character" && entry.objectId) {
+      claimed.add(entry.objectId.split("#")[0]);
+    }
+  }
+  let current = specs;
+  for (const kind of ["base", "state", "animation"]) {
+    const wave = current.filter((spec) => spec.character?.kind === kind);
+    let adoptedThisWave = 0;
+    for (const spec of wave) {
+      const key = lockKey(spec.styleId, spec.assetId);
+      if (lock.entries[key]?.status === "downloaded" && lock.entries[key]?.objectId) continue;
+      try {
+        const adopted = kind === "animation" ? await adoptAnimation(spec, key) : await adoptCharacter(spec, key);
+        if (adopted) adoptedThisWave++;
+      } catch (err) {
+        result.unmatched.push(`${key}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (adoptedThisWave) {
+      await saveLock(lockPath, lock);
+      current = await opts.resolve();
+    }
+  }
+  async function adoptCharacter(spec, key) {
+    let match;
+    if (spec.remoteId) {
+      match = remote.find((c) => c.id === spec.remoteId);
+      if (!match) throw new Error(`remoteId ${spec.remoteId} is not a character on this account`);
+    } else {
+      const south = expectedOutputPath(spec, "south", 0, spec.character.directions);
+      if (!existsSync12(south)) {
+        result.unmatched.push(`${key}: no remoteId and no ${path15.relative(process.cwd(), south)} to match by`);
+        return false;
+      }
+      const localHash = sha256(await readFile9(south));
+      for (const candidate of remote) {
+        if (claimed.has(candidate.id)) continue;
+        if (await southHash(candidate) === localHash) {
+          match = candidate;
+          break;
+        }
+      }
+      if (!match) {
+        result.unmatched.push(`${key}: no character's south rotation has the bytes of ${path15.relative(process.cwd(), south)}`);
+        return false;
+      }
+    }
+    const full = await detail(match.id);
+    if (!full.rotations.length) throw new Error(`character ${match.id} has no rotations yet (${full.status})`);
+    const outputs = await materialize(spec, full.rotations);
+    const durable = full.rotations.filter((source) => shouldPersistSourceUrl(source.url));
+    upsert(lock, key, {
+      styleId: spec.styleId,
+      assetId: spec.assetId,
+      specHash: spec.specHash,
+      generator: spec.generator,
+      prompt: full.prompt || spec.prompt,
+      width: spec.width,
+      height: spec.height,
+      jobId: full.id,
+      objectId: full.id,
+      reviewObjectId: null,
+      candidateIndex: null,
+      status: "downloaded",
+      error: null,
+      sourceUrl: durable[0]?.url ?? null,
+      sourceUrls: durable,
+      outputs,
+      providerMetadata: {
+        [provider.id]: {
+          character: {
+            characterId: full.id,
+            groupId: full.groupId,
+            name: full.name,
+            stateName: full.stateName,
+            directions: full.directions,
+            size: { width: full.width, height: full.height },
+            adopted: true
+          }
+        }
+      },
+      submittedAt: full.createdAt,
+      downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      cost: 0,
+      costUnit: "generations",
+      provider: provider.id
+    });
+    claimed.add(full.id);
+    result.matched++;
+    log2(`  adopted ${key} \u2190 character ${full.id}${full.stateName && full.stateName !== "Idle" ? ` (${full.stateName})` : ""}`);
+    return true;
+  }
+  async function adoptAnimation(spec, key) {
+    const character = spec.character;
+    const animation = character.animation;
+    const parentKey = lockKey(spec.styleId, character.parentAssetId);
+    const parentId = spec.remoteId?.split("#")[0] ?? lock.entries[parentKey]?.objectId;
+    if (!parentId) {
+      result.unmatched.push(`${key}: its parent ${parentKey} is not adopted yet`);
+      return false;
+    }
+    const full = await detail(parentId);
+    const candidates = full.animations.filter((a) => a.direction === animation.direction && a.frames.length);
+    let match;
+    if (spec.remoteId) {
+      const groupId = spec.remoteId.split("#")[1];
+      match = candidates.find((a) => a.groupId === groupId);
+      if (!match) throw new Error(`remoteId ${spec.remoteId} names no ${animation.direction} animation of character ${parentId}`);
+    } else {
+      const first = expectedOutputPath(spec, "frame-00", 0, 2);
+      if (!existsSync12(first)) {
+        const byName = candidates.find((a) => a.name === characterAnimationName(spec));
+        if (!byName) {
+          result.unmatched.push(`${key}: no remoteId and no ${path15.relative(process.cwd(), first)} to match by`);
+          return false;
+        }
+        match = byName;
+      } else {
+        const localHash = sha256(await readFile9(first));
+        for (const candidate of candidates) {
+          if (sha256(await download(candidate.frames[0])) === localHash) {
+            match = candidate;
+            break;
+          }
+        }
+        if (!match) {
+          result.unmatched.push(`${key}: no ${animation.direction} animation of character ${parentId} starts with the bytes of ${path15.relative(process.cwd(), first)}`);
+          return false;
+        }
+      }
+    }
+    const sources = match.frames.map((url, index) => ({ url, role: `frame-${String(index).padStart(2, "0")}` }));
+    const outputs = await materialize(spec, sources);
+    const durable = sources.filter((source) => shouldPersistSourceUrl(source.url));
+    const animationId = /\/animations\/([^/]+)\//.exec(match.frames[0])?.[1] ?? null;
+    upsert(lock, key, {
+      styleId: spec.styleId,
+      assetId: spec.assetId,
+      specHash: spec.specHash,
+      generator: spec.generator,
+      prompt: spec.prompt,
+      width: spec.width,
+      height: spec.height,
+      jobId: `${parentId}#${match.groupId ?? animationId ?? match.type}`,
+      objectId: `${parentId}#${match.groupId ?? animationId ?? match.type}`,
+      reviewObjectId: null,
+      candidateIndex: null,
+      status: "downloaded",
+      error: null,
+      sourceUrl: durable[0]?.url ?? null,
+      sourceUrls: durable,
+      outputs,
+      providerMetadata: {
+        [provider.id]: {
+          frameSet: { fps: animation.fps, count: sources.length },
+          character: {
+            kind: "animation",
+            characterId: parentId,
+            animationId,
+            animationGroupId: match.groupId,
+            animationName: match.name,
+            direction: animation.direction,
+            adopted: true
+          }
+        }
+      },
+      submittedAt: full.createdAt,
+      downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      cost: 0,
+      costUnit: "generations",
+      provider: provider.id
+    });
+    result.matched++;
+    log2(`  adopted ${key} \u2190 ${animation.direction} animation ${match.groupId ?? animationId ?? match.type} of ${parentId}`);
+    return true;
+  }
+  await saveLock(lockPath, lock);
+  if (!opts.noCache) {
+    pruneCache(cache, new Set(remote.map((character) => character.id)), "character:");
+    await saveCache(cachePath, cache);
+  }
+  result.remaining = remote.filter((character) => !claimed.has(character.id));
+  return result;
+}
+
+// src/pipeline/salvage.ts
+import { readFile as readFile10 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import path16 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 (!existsSync12(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!existsSync13(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile9(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile10(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -7138,20 +8102,20 @@ function matchStyleByPattern(prompt, manifest) {
   return null;
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path15.resolve(ownManifestPath);
+  const own = path16.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path15.join(path15.dirname(path15.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path16.join(path16.dirname(path16.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path15.resolve(siblingManifestPath) === own) continue;
-    if (!existsSync12(siblingManifestPath)) continue;
+    if (path16.resolve(siblingManifestPath) === own) continue;
+    if (!existsSync13(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path15.basename(path15.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path16.basename(path16.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -7267,9 +8231,9 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/workspace.ts
-import { mkdir as mkdir5, readFile as readFile10, rename as rename5, rm as rm6, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
-import path16 from "path";
+import { mkdir as mkdir6, readFile as readFile11, rename as rename5, rm as rm6, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
+import path17 from "path";
 import { z as z4 } from "zod";
 var WorkspaceProjectSchema = z4.object({
   id: z4.string().min(1),
@@ -7294,10 +8258,10 @@ ${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message
   );
 }
 async function loadWorkspace(workspacePath) {
-  if (!existsSync13(workspacePath)) return { version: 1, projects: [] };
+  if (!existsSync14(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await readFile10(workspacePath, "utf8"));
+    raw = JSON.parse(await readFile11(workspacePath, "utf8"));
   } catch (err) {
     throw new ProjectError(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -7311,22 +8275,22 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await mkdir5(path16.dirname(path16.resolve(workspacePath)), { recursive: true });
+  await mkdir6(path17.dirname(path17.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile6(tmp, JSON.stringify(sorted, null, 2) + "\n");
+    await writeFile7(tmp, JSON.stringify(sorted, null, 2) + "\n");
     await rename5(tmp, workspacePath);
   } finally {
     await rm6(tmp, { force: true });
   }
 }
 function toPortablePath(dir, absolute) {
-  return path16.relative(dir, absolute).split(path16.sep).join("/");
+  return path17.relative(dir, absolute).split(path17.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: path16.resolve(dir, project.manifest.split("/").join(path16.sep)),
-    lockPath: path16.resolve(dir, project.lock.split("/").join(path16.sep))
+    manifestPath: path17.resolve(dir, project.manifest.split("/").join(path17.sep)),
+    lockPath: path17.resolve(dir, project.lock.split("/").join(path17.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -7339,21 +8303,21 @@ function validateWorkspace(ws, dir) {
     const { manifestPath, lockPath } = resolveProject(dir, project);
     lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
     manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
-    if (path16.isAbsolute(project.manifest) || path16.isAbsolute(project.lock)) {
+    if (path17.isAbsolute(project.manifest) || path17.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
-        message: `project "${project.id}" stores an absolute path \u2014 the catalog will not resolve correctly if this tree is cloned or moved elsewhere`
+        message: `project "${project.id}" stores an absolute path; the catalog will not resolve correctly if this tree is cloned or moved elsewhere`
       });
     }
-    if (!existsSync13(manifestPath)) {
+    if (!existsSync14(manifestPath)) {
       diagnostics.push({
         id: "missing-manifest",
         level: "error",
         message: `project "${project.id}" manifest not found: ${manifestPath}`
       });
     }
-    if (!existsSync13(lockPath)) {
+    if (!existsSync14(lockPath)) {
       diagnostics.push({
         id: "missing-lock",
         level: "error",
@@ -7384,7 +8348,7 @@ function validateWorkspace(ws, dir) {
       diagnostics.push({
         id: "duplicate-manifest",
         level: "warning",
-        message: `${ids.join(", ")} share manifest ${manifestPath} \u2014 expected only when they are variant lockfiles beside one manifest`
+        message: `${ids.join(", ")} share manifest ${manifestPath}; expected only when they are variant lockfiles beside one manifest`
       });
     }
   }
@@ -7393,15 +8357,15 @@ function validateWorkspace(ws, dir) {
     diagnostics.push({
       id: "mixed-provider",
       level: "warning",
-      message: `registered projects use different providers: ${[...providers].sort().join(", ")} \u2014 spend totals are kept separate per unit, but confirm this is intentional`
+      message: `registered providers differ (${[...providers].sort().join(", ")}); spend totals are kept separate per unit, but confirm this is intentional`
     });
   }
   return diagnostics;
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir6, writeFile as writeFile7, readFile as readFile12 } from "fs/promises";
-import path17 from "path";
+import { mkdir as mkdir7, writeFile as writeFile8, readFile as readFile13 } from "fs/promises";
+import path18 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -7414,7 +8378,7 @@ function renderSalvageSheet(orphans, ctx) {
 <html lang="en">
 <head>
 <meta charset="utf-8">
-<title>pixelkiln salvage${styleId ? ` \u2014 ${styleId}` : ""}</title>
+<title>${styleId ? `${styleId} | ` : ""}pixelkiln salvage</title>
 <style>
   :root { --bg:#0f1115; --panel:#171a21; --line:#262b36; --text:#e6e8ee; --dim:#8b93a7;
           --import:#6ee7a8; --keep:#7cc4ff; --discard:#f87171; }
@@ -7465,7 +8429,7 @@ function renderSalvageSheet(orphans, ctx) {
 </head>
 <body>
 <header>
-  <h1>pixelkiln salvage${styleId ? ` <span class="ctx">\u2014 ${styleId}<span class="dest"> \u2192 ${importDir}/_salvaged/</span></span>` : ""}</h1>
+  <h1>pixelkiln salvage${styleId ? ` <span class="ctx">${styleId}<span class="dest">, imports to ${importDir}/_salvaged/</span></span>` : ""}</h1>
   <span class="tally"><b id="ti">0</b> import \xB7 <b id="tk">0</b> keep \xB7 <b id="td">0</b> discard \xB7
     <b id="tu">0</b> undecided</span>
   <span style="flex:1"></span>
@@ -7476,7 +8440,7 @@ function renderSalvageSheet(orphans, ctx) {
 <main id="grid"></main>
 <footer>
   <b>import</b> downloads it and adds it to your manifest \xB7 <b>keep</b> tags it and leaves it \xB7
-  <b>discard</b> only tags it \u2014 nothing is deleted here.
+  <b>discard</b> only tags it; nothing is deleted here.
   Hover a card and press <kbd>i</kbd> / <kbd>k</kbd> / <kbd>d</kbd>, or <kbd>u</kbd> to undo.
 </footer>
 <script>
@@ -7547,7 +8511,7 @@ document.getElementById('submit').onclick = async () => {
       body: JSON.stringify({ decisions }),
     });
     if (!res.ok) throw new Error(await res.text());
-    btn.textContent = 'done \u2014 close this tab';
+    btn.textContent = 'done, close this tab';
     document.body.style.opacity = '.6';
   } catch (err) {
     btn.textContent = 'failed: ' + err.message; btn.disabled = false;
@@ -7561,7 +8525,7 @@ refresh();
 
 // src/pick/review-server.ts
 import { createServer } from "http";
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 
 // src/open.ts
 import { spawn } from "child_process";
@@ -7588,7 +8552,7 @@ function serveReviewPage(opts) {
       if (req.method === "GET" && req.url && opts.assets?.has(req.url)) {
         try {
           const asset = opts.assets.get(req.url);
-          const bytes = await readFile11(asset.path);
+          const bytes = await readFile12(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -7665,7 +8629,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path17.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path18.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]));
@@ -7677,7 +8641,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
     onReady: (url) => {
       log2(`
   ${orphans.length} unclaimed object(s) to triage: ${url}`);
-      log2(`  (nothing is deleted here \u2014 discard only tags)
+      log2(`  (nothing is deleted here; discard only tags)
 `);
     },
     handleApply: async (body) => {
@@ -7694,10 +8658,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 = path17.join("_salvaged", `${assetId}.png`);
-            const outFile = path17.resolve(ctx.importDir, rel);
-            await mkdir6(path17.dirname(outFile), { recursive: true });
-            await writeFile7(outFile, buf);
+            const rel = path18.join("_salvaged", `${assetId}.png`);
+            const outFile = path18.resolve(ctx.importDir, rel);
+            await mkdir7(path18.dirname(outFile), { recursive: true });
+            await writeFile8(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -7729,7 +8693,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path17.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path18.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -7753,9 +8717,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log2 });
-      const raw = JSON.parse(await readFile12(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile13(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await writeFile7(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile8(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       return result;
     }
@@ -7763,19 +8727,19 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 }
 
 // src/cli/project.ts
-import path19 from "path";
-import { existsSync as existsSync14 } from "fs";
+import path20 from "path";
+import { existsSync as existsSync15 } from "fs";
 
 // src/project.ts
-import path18 from "path";
+import path19 from "path";
 async function openProject(manifestPath = "pixelkiln.manifest.json", opts = {}) {
-  const absolute = path18.resolve(manifestPath);
-  const root = path18.dirname(absolute);
+  const absolute = path19.resolve(manifestPath);
+  const root = path19.dirname(absolute);
   if (opts.env !== false) {
     loadEnvFiles(root);
-    if (path18.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
+    if (path19.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
   }
-  const lockPath = path18.resolve(opts.lockPath ?? path18.join(root, "pixelkiln.lock.json"));
+  const lockPath = path19.resolve(opts.lockPath ?? path19.join(root, "pixelkiln.lock.json"));
   const loaded = await loadManifest(absolute);
   const specs = await resolveSpecs(loaded, { styles: opts.styles ?? [], assets: opts.assets ?? [] });
   const lock = await loadLock(lockPath);
@@ -7906,11 +8870,11 @@ async function workspaceStatus(ws, dir) {
 
 // src/cli/project.ts
 async function provenanceFile(id, file) {
-  const absolute = path19.resolve(file);
+  const absolute = path20.resolve(file);
   return {
     id,
     path: absolute,
-    sha256: existsSync14(absolute) ? await sha256File(absolute) : null,
+    sha256: existsSync15(absolute) ? await sha256File(absolute) : null,
     included: true
   };
 }
@@ -7982,10 +8946,10 @@ function budgetsForPlan(plan, args) {
   return out;
 }
 async function requireCompleteWorkspaceClaims(workspacePath) {
-  if (!existsSync14(workspacePath)) {
+  if (!existsSync15(workspacePath)) {
     throw new ProjectError(`Workspace catalog not found: ${workspacePath}`);
   }
-  const dir = path19.dirname(path19.resolve(workspacePath));
+  const dir = path20.dirname(path20.resolve(workspacePath));
   const ws = await loadWorkspace(workspacePath);
   const diagnostics = validateWorkspace(ws, dir);
   const errors = diagnostics.filter((d) => d.level === "error");
@@ -8008,9 +8972,9 @@ async function openAccountProject(args) {
   return project;
 }
 async function open(args) {
-  if (!existsSync14(path19.resolve(args.manifest))) {
+  if (!existsSync15(path20.resolve(args.manifest))) {
     throw new ProjectError(
-      `No manifest at ${path19.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
+      `No manifest at ${path20.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
     );
   }
   const project = await openProject(args.manifest, { lockPath: args.lock, styles: args.styles, assets: args.assets });
@@ -8052,7 +9016,7 @@ function providerCache(mode2) {
 
 // src/cli/commands/account.ts
 async function runBalance(args) {
-  loadEnvFiles(path20.dirname(path20.resolve(args.manifest)));
+  loadEnvFiles(path21.dirname(path21.resolve(args.manifest)));
   loadEnvFiles(process.cwd());
   const loaded = await loadManifest(args.manifest);
   const selectedProvider = accountProviderId(loaded.manifest, args.provider, "balance");
@@ -8063,14 +9027,40 @@ async function runBalance(args) {
   log(`  remaining: ${formatCost(b.unit, b.remaining)}${b.total ? ` of ${b.total}` : ""}`);
 }
 async function runAdopt(args) {
-  const { specs, lock, accountProvider } = await openAccountProject(args);
+  const { loaded, specs, lock, accountProvider } = await openAccountProject(args);
   const providerFor = providerCache("online");
   const provider = providerFor(accountProvider);
   log(`
   Reconciling account objects against files already on disk\u2026`);
-  const res = await adopt(provider, specs, lock, args.lock, { onProgress: log });
+  const res = await adopt(provider, specs.filter((spec) => spec.generator !== "character"), lock, args.lock, { onProgress: log });
   log(`
   scanned ${res.scanned} remote object(s), adopted ${res.matched}`);
+  if (specs.some((spec) => spec.character) && provider.listCharacters) {
+    log(`
+  Reconciling account characters against the manifest's character assets\u2026`);
+    const characters = await adoptCharacters(provider, specs, lock, args.lock, {
+      onProgress: log,
+      resolve: async () => (await resolveSpecs(loaded, { styles: args.styles, assets: args.assets })).filter((spec) => spec.provider === accountProvider)
+    });
+    log(`
+  scanned ${characters.scanned} character(s), adopted ${characters.matched}`);
+    if (characters.written.length) log(`  wrote ${characters.written.length} file(s) that were not on disk`);
+    for (const file of characters.differing) log(`  differs from the account, left alone: ${file}`);
+    if (characters.unmatched.length) {
+      log(`
+  character assets not matched (${characters.unmatched.length}):`);
+      for (const line of characters.unmatched.slice(0, 15)) log(`    ${line}`);
+    }
+    if (characters.remaining.length) {
+      log(`
+  characters on the account no entry claims (${characters.remaining.length}):`);
+      for (const c of characters.remaining.slice(0, 15)) {
+        log(`    ${c.id}  ${c.name}${c.stateName && c.stateName !== "Idle" ? ` / ${c.stateName}` : ""}  ${c.directions}dir ${c.width}x${c.height}  ${c.animationCount} animation(s)`);
+      }
+      if (characters.remaining.length > 15) log(`    \u2026 and ${characters.remaining.length - 15} more`);
+      log(`  Declare one as a character asset with "remoteId" and run adopt again to bring it in.`);
+    }
+  }
   if (res.ambiguous.length) {
     log(`
   ambiguous (${res.ambiguous.length}):`);
@@ -8089,7 +9079,7 @@ async function runAdopt(args) {
       `
   One account is shared across projects, so this list mixes discarded
   candidates with assets belonging to other manifests. Do not bulk-delete
-  it \u2014 run adopt from each project first, then \`pixelkiln salvage\` to
+  it. Run adopt from each project first, then \`pixelkiln salvage\` to
   triage what is left over.`
     );
   }
@@ -8099,12 +9089,12 @@ async function runAdopt(args) {
   tagged ${n} object(s) upstream`);
   }
   if (args.writePrompts) {
-    const { filled, stillEmpty } = await writePromptsBack(path20.resolve(args.manifest), lock, {
+    const { filled, stillEmpty } = await writePromptsBack(path21.resolve(args.manifest), lock, {
       onProgress: log,
       provider: provider.id,
       assetIds: specs.map((spec) => spec.assetId)
     });
-    log(`  recovered ${filled} prompt(s) into ${path20.relative(process.cwd(), args.manifest)}`);
+    log(`  recovered ${filled} prompt(s) into ${path21.relative(process.cwd(), args.manifest)}`);
     const reloaded = await loadManifest(args.manifest);
     const rebased = (await resolveSpecs(reloaded, {
       styles: args.styles,
@@ -8134,12 +9124,12 @@ async function runSalvage2(args) {
   const provider = providerFor(accountProvider);
   const jsonMode = args.dryRun && args.json;
   const diag = jsonMode ? (msg = "") => console.error(msg) : log;
-  const ownLock = path20.resolve(args.lock);
+  const ownLock = path21.resolve(args.lock);
   let workspaceProjects = [];
   let workspaceDir = "";
   if (args.workspace) {
-    const workspacePath = path20.resolve(args.workspace);
-    workspaceDir = path20.dirname(workspacePath);
+    const workspacePath = path21.resolve(args.workspace);
+    workspaceDir = path21.dirname(workspacePath);
     const complete = await requireCompleteWorkspaceClaims(workspacePath);
     workspaceProjects = complete.ws.projects;
     for (const d of complete.diagnostics) diag(`  WARN  ${d.id}: ${d.message}`);
@@ -8148,12 +9138,12 @@ async function runSalvage2(args) {
   const lockPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceLockPaths,
-      ...existsSync15(ownLock) ? [ownLock] : [],
-      ...args.claims.map((c) => path20.resolve(c))
+      ...existsSync16(ownLock) ? [ownLock] : [],
+      ...args.claims.map((c) => path21.resolve(c))
     ])
   ];
   diag(`  claim set (${lockPaths.length} lockfile(s)):`);
-  for (const p of lockPaths) diag(`    ${path20.relative(process.cwd(), p)}`);
+  for (const p of lockPaths) diag(`    ${path21.relative(process.cwd(), p)}`);
   if (!args.claims.length && !args.workspace) {
     diag(
       `
@@ -8161,11 +9151,11 @@ async function runSalvage2(args) {
   pass every other project's lockfile via --claims a.json,b.json, or
   register every project in a workspace catalog and pass --workspace.`
     );
-  } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path20.resolve(args.manifest))) {
+  } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path21.resolve(args.manifest))) {
     diag(
       `
   This project's manifest is not registered in the workspace catalog. Its own
-  lockfile is still included above, so this run's claim set is complete \u2014 but
+  lockfile is still included above, so this run's claim set is complete, but
   \`pixelkiln workspace add ${args.manifest}\` would keep it aggregated too.`
     );
   }
@@ -8195,13 +9185,13 @@ async function runSalvage2(args) {
     diag(`
   matched a sibling project's own style instead of this one:`);
     for (const [label, list] of elsewhere) diag(`    ${label.padEnd(28)} ${list.length}`);
-    diag(`  excluded from every session below \u2014 not this project's art.`);
+    diag(`  excluded from every session below; not this project's art.`);
   }
   if (unmatched.length) {
     diag(
       `
   ${unmatched.length} object(s) don't match any known style pattern.
-  If the account is shared, they may belong to a different project \u2014 check
+  If the account is shared, they may belong to a different project. Check
   you've passed every sibling project's lockfile via --claims. They're left
   out of the sessions below; force them into one style with --style <id>.`
     );
@@ -8245,7 +9235,7 @@ async function runSalvage2(args) {
         manifestPath: loaded.path,
         manifest: accountManifest,
         styleId,
-        importDir: path20.resolve(loaded.root, style.outDir),
+        importDir: path21.resolve(loaded.root, style.outDir),
         lock,
         lockPath: args.lock
       },
@@ -8269,7 +9259,7 @@ async function runSalvage2(args) {
   }
   if (!matched.size) {
     log(`
-  nothing matched a known style \u2014 nothing to triage`);
+  nothing matched a known style; nothing to triage`);
     return;
   }
   log(`
@@ -8277,7 +9267,7 @@ async function runSalvage2(args) {
   let totalDiscarded = 0;
   for (const [styleId, list] of matched) {
     log(`
-  \u2014 ${styleId} (${list.length}) \u2014`);
+  ${styleId} (${list.length})`);
     const res = await runOne(styleId, list);
     totalDiscarded += res.discarded;
   }
@@ -8299,7 +9289,7 @@ async function runPurge(args) {
     }
   }
   if (!doomed.length) {
-    log(`  nothing tagged pixelkiln:discard \u2014 run \`pixelkiln salvage\` first`);
+    log(`  nothing tagged pixelkiln:discard; run \`pixelkiln salvage\` first`);
     return;
   }
   log(`
@@ -8346,17 +9336,17 @@ async function runTag(args) {
 }
 
 // src/cli/commands/edit.ts
-import path23 from "path";
+import path24 from "path";
 
 // src/pipeline/hand-edit.ts
-import { existsSync as existsSync16 } from "fs";
-import { copyFile, mkdir as mkdir7, readFile as readFile14, rename as rename7, rm as rm8, writeFile as writeFile9 } from "fs/promises";
-import path22 from "path";
+import { existsSync as existsSync17 } from "fs";
+import { copyFile, mkdir as mkdir8, readFile as readFile15, rename as rename7, rm as rm8, writeFile as writeFile10 } from "fs/promises";
+import path23 from "path";
 import { z as z6 } from "zod";
 
 // src/manifest-edit.ts
-import { readFile as readFile13, rename as rename6, rm as rm7, writeFile as writeFile8 } from "fs/promises";
-import path21 from "path";
+import { readFile as readFile14, rename as rename6, rm as rm7, writeFile as writeFile9 } from "fs/promises";
+import path22 from "path";
 import { z as z5 } from "zod";
 var HexSha = z5.string().regex(/^[0-9a-f]{64}$/);
 var AssetPatchSchema = z5.object({
@@ -8571,8 +9561,8 @@ function applyEdit(raw, edit) {
   }
 }
 async function applyManifestEdit(manifestPath, edit) {
-  const absolute = path21.resolve(manifestPath);
-  const original = await readFile13(absolute, "utf8");
+  const absolute = path22.resolve(manifestPath);
+  const original = await readFile14(absolute, "utf8");
   const before = sha256(original);
   if (before !== edit.expectedSha256) throw new ManifestDriftError(absolute);
   let raw;
@@ -8586,12 +9576,12 @@ async function applyManifestEdit(manifestPath, edit) {
   applyEdit(raw, edit);
   const next = serializeLike(original, raw);
   if (next === original) return { manifestPath: absolute, sha256: before, changed: false };
-  const tmp = path21.join(
-    path21.dirname(absolute),
-    `.${path21.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
+  const tmp = path22.join(
+    path22.dirname(absolute),
+    `.${path22.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
   );
   try {
-    await writeFile8(tmp, next);
+    await writeFile9(tmp, next);
     try {
       const loaded = await loadManifest(tmp);
       await resolveSpecs(loaded);
@@ -8610,11 +9600,11 @@ async function applyManifestEdit(manifestPath, edit) {
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
-  const outDir = path22.resolve(loaded.root, style?.outDir ?? ".");
-  const relative = path22.relative(outDir, spec.outFile);
-  const inside = relative && !relative.startsWith("..") && !path22.isAbsolute(relative);
-  const file = inside ? relative : path22.basename(spec.outFile);
-  return path22.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
+  const outDir = path23.resolve(loaded.root, style?.outDir ?? ".");
+  const relative = path23.relative(outDir, spec.outFile);
+  const inside = relative && !relative.startsWith("..") && !path23.isAbsolute(relative);
+  const file = inside ? relative : path23.basename(spec.outFile);
+  return path23.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
 }
 function handEditBases(spec, lock) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -8627,10 +9617,10 @@ function handEditBases(spec, lock) {
     }));
     if (members.some((member) => member.mediaType && member.mediaType !== "image/png")) return null;
     if (entry.outputs.length === 1 && !primaryOutput(entry)) return null;
-    if (!members.every((member) => existsSync16(member.path))) return null;
+    if (!members.every((member) => existsSync17(member.path))) return null;
     return members.map(({ role, path: file }) => ({ role, path: file }));
   }
-  return existsSync16(spec.outFile) ? [{ role: null, path: spec.outFile }] : null;
+  return existsSync17(spec.outFile) ? [{ role: null, path: spec.outFile }] : null;
 }
 function handEditMembers(loaded, spec, lock, editPath) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -8656,18 +9646,18 @@ async function startHandEdit(loaded, lock, spec, opts = {}) {
       `${spec.styleId}/${spec.assetId} declares ${spec.source}, one committed file placed for the whole set; clear that source (pixelkiln edit detach) to hand-edit the members one by one`
     );
   }
-  const existing = spec.source ? path22.resolve(loaded.root, spec.source) : null;
+  const existing = spec.source ? path23.resolve(loaded.root, spec.source) : null;
   const editPath = existing ?? handEditPath(loaded, spec);
   const members = handEditMembers(loaded, spec, lock, editPath);
   let created = false;
   for (const member of members) {
-    if (existsSync16(member.path)) continue;
+    if (existsSync17(member.path)) continue;
     if (!member.base) {
       throw new ManifestEditError(
         `${spec.styleId}/${spec.assetId} has no generated PNG on disk to start from; generate or restore it first`
       );
     }
-    await mkdir7(path22.dirname(member.path), { recursive: true });
+    await mkdir8(path23.dirname(member.path), { recursive: true });
     await copyFile(member.base, member.path);
     created = true;
   }
@@ -8746,7 +9736,7 @@ function handEditProjectPath(editPath) {
 async function readHandEditCompanion(editPath) {
   let text;
   try {
-    text = await readFile14(handEditCompanionPath(editPath), "utf8");
+    text = await readFile15(handEditCompanionPath(editPath), "utf8");
   } catch {
     return null;
   }
@@ -8770,11 +9760,11 @@ async function saveHandEdit(loaded, lock, spec, input) {
     const got = incoming.map((frame) => frame.role);
     if (got.length !== expected.length || expected.some((role, index) => got[index] !== role)) {
       throw new ManifestEditError(
-        `${spec.styleId}/${spec.assetId} is a set of ${expected.length} members (${expected.join(", ")}); the editor returned ${got.length} (${got.map((role) => role ?? "new").join(", ")}) \u2014 keep the frames it opened with`
+        `${spec.styleId}/${spec.assetId} is a set of ${expected.length} members (${expected.join(", ")}); the editor returned ${got.length} (${got.map((role) => role ?? "new").join(", ")}); keep the frames it opened with`
       );
     }
   } else if (incoming.length !== 1) {
-    throw new ManifestEditError(`${spec.styleId}/${spec.assetId} is one image; the editor returned ${incoming.length} frames \u2014 keep a single frame`);
+    throw new ManifestEditError(`${spec.styleId}/${spec.assetId} is one image; the editor returned ${incoming.length} frames; keep a single frame`);
   }
   const decoded = incoming.map((frame, index) => {
     if (frame.png.length > MAX_HAND_EDIT_BYTES) {
@@ -8789,7 +9779,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     }
   });
   const bases = handEditBases(spec, lock);
-  const expectedSize = bases?.[0] ? decodePng(await readFile14(bases[0].path)) : { width: spec.width, height: spec.height };
+  const expectedSize = bases?.[0] ? decodePng(await readFile15(bases[0].path)) : { width: spec.width, height: spec.height };
   for (const [index, image] of decoded.entries()) {
     if (image.width !== expectedSize.width || image.height !== expectedSize.height) {
       const which = memberSet ? `member ${incoming[index].role ?? index}` : "the edit";
@@ -8805,7 +9795,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     editor: input.editor,
     protocol: input.protocol,
     savedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
-    project: projectPath ? path22.basename(projectPath) : null,
+    project: projectPath ? path23.basename(projectPath) : null,
     outputs: incoming.map((frame, index) => ({
       role: frame.role,
       basedOn: basedOnHash(entry, index),
@@ -8835,7 +9825,7 @@ function basedOnHash(entry, index) {
 async function replaceFile(file, bytes) {
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile9(tmp, bytes);
+    await writeFile10(tmp, bytes);
     await rename7(tmp, file);
   } finally {
     await rm8(tmp, { force: true });
@@ -8865,7 +9855,7 @@ async function runEdit(args) {
   const set = started.members.length > 1;
   const kind = spec.generator === "frames" ? "frames" : "members";
   log(`  ${started.created ? "created" : "found"} ${started.source}${set ? ` (${started.members.length} ${kind})` : ""}${started.declared ? " and declared it as the asset's source" : ""}`);
-  if (set) for (const member of started.members) log(`    ${member.role ?? ""}  ${path23.relative(process.cwd(), member.path)}`);
+  if (set) for (const member of started.members) log(`    ${member.role ?? ""}  ${path24.relative(process.cwd(), member.path)}`);
   if (args.noOpen) {
     log(`  edit ${set ? "them" : "it"} with your own tool, then run pixelkiln plan; mount and pack place ${set ? "them" : "it"} in place of the generated art`);
   } else {
@@ -8875,17 +9865,17 @@ async function runEdit(args) {
 }
 
 // src/cli/commands/gallery.ts
-import path30 from "path";
-import { existsSync as existsSync22 } from "fs";
+import path31 from "path";
+import { existsSync as existsSync23 } from "fs";
 
 // src/gallery/snapshot.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync18 } from "fs";
-import { readFile as readFile15, stat as stat2 } from "fs/promises";
-import path26 from "path";
+import { existsSync as existsSync19 } from "fs";
+import { readFile as readFile16, stat as stat2 } from "fs/promises";
+import path27 from "path";
 
 // src/gallery/edit.ts
-import path24 from "path";
+import path25 from "path";
 import { z as z7 } from "zod";
 var Base64 = z7.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
 var HandEditRequestSchema = z7.discriminatedUnion("action", [
@@ -8975,7 +9965,7 @@ function createGalleryEditHandler(opts) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = path24.relative(process.cwd(), result.manifestPath);
+      const relative = path25.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;
       log2(`  manifest edited: ${parsed.data.action === "add-asset" ? "added" : "changed"} ${subject} in ${shown}`);
@@ -8985,8 +9975,8 @@ function createGalleryEditHandler(opts) {
 }
 
 // src/pipeline/history.ts
-import { existsSync as existsSync17 } from "fs";
-import path25 from "path";
+import { existsSync as existsSync18 } from "fs";
+import path26 from "path";
 var HISTORY_ENV = "PIXELKILN_HISTORY";
 function historyLimit(manifest, env = process.env) {
   if (manifest?.history !== void 0) return manifest.history;
@@ -9072,10 +10062,10 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
   }
   for (let i = 0; i < entry.outputs.length; i++) {
     const file = currentEntryOutputPath(entry, spec, i);
-    if (!existsSync17(file)) continue;
+    if (!existsSync18(file)) continue;
     if (await sha256File(file) !== entry.outputs[i].sha256 && !opts.force) {
       throw new OverwriteRefusedError(
-        `${path25.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
+        `${path26.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
         [file]
       );
     }
@@ -9127,7 +10117,7 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return createHash3("sha256").update(path26.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return createHash3("sha256").update(path27.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
@@ -9146,9 +10136,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 = path26.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = path27.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if (existsSync18(file)) {
+      if (existsSync19(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -9177,7 +10167,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([readFile15(a), readFile15(b)]);
+    const [left, right] = await Promise.all([readFile16(a), readFile16(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -9221,10 +10211,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, path26.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, path27.resolve(root, file)))
   );
-  const recordPath = path26.resolve(root, inspection.record);
-  const recordExists = existsSync18(recordPath);
+  const recordPath = path27.resolve(root, inspection.record);
+  const recordExists = existsSync19(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -9243,7 +10233,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(path26.resolve(root, inspection.output), root),
+    output: portableOutputPath(path27.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -9280,9 +10270,9 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await readFile15(loaded.path, "utf8");
+  const manifestText = await readFile16(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = path26.resolve(path26.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = path27.resolve(path27.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -9306,12 +10296,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = path26.resolve(root, spec.source);
+        const editPath = path27.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: existsSync18(file) ? await sha256File(file) : null };
+            return { file, sha256: existsSync19(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -9319,7 +10309,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && existsSync18(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && existsSync19(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -9355,8 +10345,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, path26.resolve(root, spec.source))];
-    } else if (!entry && existsSync18(spec.outFile)) {
+      outputs = [await describeOutput(media, root, path27.resolve(root, spec.source))];
+    } else if (!entry && existsSync19(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -9538,7 +10528,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: path26.resolve(opts.lockPath),
+      lock: path27.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -9564,7 +10554,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = path26.dirname(path26.resolve(opts.workspacePath));
+  const dir = path27.dirname(path27.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -9607,11 +10597,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: path26.resolve(lockPath),
+        lock: path27.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await readFile15(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await readFile16(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -9623,8 +10613,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: path26.resolve(lockPath),
-        root: path26.dirname(manifestPath),
+        lock: path27.resolve(lockPath),
+        root: path27.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -9651,7 +10641,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: path26.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: path27.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -9670,7 +10660,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 // src/gallery/server.ts
 import { randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 
 // src/gallery/page.ts
 import { readFileSync as readFileSync4 } from "fs";
@@ -9689,7 +10679,7 @@ function renderGallery(snapshot, opts = {}) {
   const editable = JSON.stringify(Boolean(opts.editable && opts.session));
   const generation = JSON.stringify(Boolean(opts.generation && opts.session));
   const editor = JSON.stringify(Boolean(opts.editor && opts.session));
-  const title = `pixelkiln \u2014 ${snapshot.project?.name ?? "workspace"}`;
+  const title = `${snapshot.project?.name ?? "workspace"} | pixelkiln`;
   const { css, js } = clientAssets();
   return `<!doctype html>
 <html lang="en">
@@ -9732,7 +10722,7 @@ ${css}</style>
 <footer>
   Click a sprite for its full record; <kbd>shift</kbd>-click adds it to a side-by-side comparison. <kbd>\u2190</kbd>/<kbd>\u2192</kbd> step through the visible set while a record
   is open, <kbd>Esc</kbd> closes it, and <kbd>/</kbd> jumps to search. This page reads the manifest, lockfile,
-  and disk only \u2014 it never contacts a provider<span id="foot-edit"> and never writes anything</span><span id="foot-editing" hidden>.
+  and disk only. It never contacts a provider<span id="foot-edit"> and never writes anything</span><span id="foot-editing" hidden>.
   Editing is on: saving rewrites the manifest and nothing else</span><span id="foot-gen" hidden>.
   Generation is on under the session budget shown above; every run is the same submit, poll, and fetch as <code>pixelkiln gen</code></span>.
   <span id="note"></span>
@@ -9911,7 +10901,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 readFile16(asset.path);
+          const bytes = await readFile17(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -9987,7 +10977,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await readFile16(asset.path);
+          bytes = await readFile17(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -10057,7 +11047,7 @@ async function poll(provider, lock, lockPath, opts = {}) {
   while (pending().length > 0) {
     if (Date.now() - started > timeout) {
       result.stillRunning += pending().length;
-      log2(`  timed out with ${result.stillRunning} job(s) still running \u2014 re-run \`poll\` to resume`);
+      log2(`  timed out with ${result.stillRunning} job(s) still running; re-run \`poll\` to resume`);
       break;
     }
     for (const [key, entry] of pending()) {
@@ -10065,7 +11055,8 @@ async function poll(provider, lock, lockPath, opts = {}) {
         const currentSpec = specByKey.get(key);
         const state = await provider.poll(entry.jobId, entry.generator, {
           tileFeature: entry.tileFeature ?? currentSpec?.tileFeature,
-          spec: currentSpec
+          spec: currentSpec,
+          metadata: entry.providerMetadata?.[provider.id]
         });
         if (state.status === "review" || state.status === "review-set") {
           upsert(lock, key, {
@@ -10237,8 +11228,12 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
     lastSubmitAt = Date.now();
     try {
       const refs = styleImages.get(spec.styleId) ?? [];
+      const parentEntry = spec.character?.parentSpec ? lock.entries[lockKey(spec.character.parentSpec.styleId, spec.character.parentSpec.assetId)] : void 0;
+      const replacedMetadata = previousEntry?.providerMetadata?.[provider.id];
       const { jobId, metadata } = await provider.submit(spec, refs, {
         ...previousJobId ? { previousJobId } : {},
+        ...parentEntry?.objectId ? { parentObjectId: parentEntry.objectId } : {},
+        ...replacedMetadata ? { replacedMetadata } : {},
         ...previousMetadata ? { previousMetadata } : {},
         checkpoint: async (checkpoint) => {
           if (!checkpoint.jobId) throw new Error("Provider checkpoint returned an empty job id");
@@ -10300,13 +11295,13 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
 }
 
 // src/pick/server.ts
-import { existsSync as existsSync20 } from "fs";
-import { readFile as readFile18 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
+import { readFile as readFile19 } from "fs/promises";
 
 // src/pipeline/init.ts
-import { readdir, readFile as readFile17, writeFile as writeFile10 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import path27 from "path";
+import { readdir, readFile as readFile18, writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import path28 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -10320,7 +11315,7 @@ function slugify(value) {
 async function walk(dir, exclude) {
   const out = [];
   for (const entry of await readdir(dir, { withFileTypes: true })) {
-    const full = path27.join(dir, entry.name);
+    const full = path28.join(dir, entry.name);
     if (exclude.some((x) => full.includes(x))) continue;
     if (entry.isDirectory()) out.push(...await walk(full, exclude));
     else if (entry.name.toLowerCase().endsWith(".png")) out.push(full);
@@ -10334,14 +11329,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await readFile17(file));
+    const size = pngSize(await readFile18(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = path27.relative(root, file);
-    const category = path27.dirname(rel) === "." ? "" : path27.dirname(rel);
-    let id = slugify(path27.basename(rel));
+    const rel = path28.relative(root, file);
+    const category = path28.dirname(rel) === "." ? "" : path28.dirname(rel);
+    let id = slugify(path28.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -10399,10 +11394,10 @@ function mode(values) {
   return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 64;
 }
 async function writeManifestFile(target, manifest) {
-  if (existsSync19(target)) {
-    throw new Error(`${target} already exists \u2014 refusing to overwrite an existing manifest.`);
+  if (existsSync20(target)) {
+    throw new Error(`${target} already exists; refusing to overwrite an existing manifest.`);
   }
-  await writeFile10(target, JSON.stringify(manifest, null, 2) + "\n");
+  await writeFile11(target, JSON.stringify(manifest, null, 2) + "\n");
 }
 
 // src/pick/sheet.ts
@@ -10431,7 +11426,7 @@ function renderSheet(groups, options = {}) {
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>pixelkiln \u2014 pick candidates</title>
+<title>pick candidates | pixelkiln</title>
 <style>
   :root {
     --bg: #17150f; --panel: #201d17; --panel-deep: #100f0c;
@@ -10532,7 +11527,7 @@ function renderSheet(groups, options = {}) {
   click again to undo. In the focused row,
   <kbd>\u2190</kbd>/<kbd>\u2192</kbd> browses every candidate and <kbd>Enter</kbd> chooses;
   <kbd>1</kbd>\u2013<kbd>9</kbd> picks directly, <kbd>0</kbd> skips, and
-  <kbd>\u2191</kbd>/<kbd>\u2193</kbd> changes rows. Unchosen rows stay in review \u2014 nothing is
+  <kbd>\u2191</kbd>/<kbd>\u2193</kbd> changes rows. Unchosen rows stay in review; nothing is
   discarded by closing this page.
 </footer>
 <script>
@@ -10781,7 +11776,7 @@ document.getElementById('submit').onclick = async () => {
     });
     if (!res.ok) throw new Error(await res.text());
     const result = await res.json();
-    status.textContent = APPLY.embedded ? 'applied' : 'done \u2014 you can close this tab';
+    status.textContent = APPLY.embedded ? 'applied' : 'done, you can close this tab';
     document.body.style.opacity = '.6';
     if (APPLY.embedded && window.parent !== window) {
       window.parent.postMessage({ type: 'pixelkiln:review-applied', result }, location.origin);
@@ -10802,13 +11797,13 @@ async function currentArt(entry, spec) {
   const previous = primaryOutput({ ...entry, outputs: entry.supersededOutputs });
   if (!previous) return null;
   const file = resolveOutputPath(previous.path, spec.root);
-  if (!existsSync20(file)) return null;
+  if (!existsSync21(file)) return null;
   const contentType = previous.mediaType ?? mediaTypeFromExtension(file);
   if (!contentType) return null;
   let width = entry.width;
   let height = entry.height;
   if (contentType === "image/png") {
-    const size = pngSize(await readFile18(file));
+    const size = pngSize(await readFile19(file));
     if (size) ({ width, height } = size);
   }
   return { path: file, contentType, width, height };
@@ -10828,7 +11823,7 @@ async function prepareReview(provider, lock, opts = {}) {
     if (entry.status !== "review" || !entry.reviewObjectId) continue;
     try {
       const spec = specByKey.get(key);
-      const state = await provider.poll(entry.reviewObjectId, entry.generator, { spec });
+      const state = await provider.poll(entry.reviewObjectId, entry.generator, { spec, metadata: entry.providerMetadata?.[provider.id] });
       if (state.status !== "review" && state.status !== "review-set" || (state.status === "review" ? !state.candidateUrls.length : !state.frameUrls.length)) continue;
       const frameUrls = state.status === "review" ? state.candidateUrls : state.frameUrls;
       const sourceRoute = spec?.revision ? `${prefix}/revision-source/${encodeURIComponent(String(groups.length))}` : null;
@@ -10888,7 +11883,7 @@ async function prepareReview(provider, lock, opts = {}) {
         if (!Number.isInteger(index) || index < 0 || index >= group.frameUrls.length) continue;
         if (group.mode === "frame-set") {
           const spec = specByKey.get(key);
-          const state = await provider.poll(entry.reviewObjectId, entry.generator, { spec });
+          const state = await provider.poll(entry.reviewObjectId, entry.generator, { spec, metadata: entry.providerMetadata?.[provider.id] });
           if (state.status !== "review-set") {
             throw new Error(`Frame set ${key} is no longer ready for review`);
           }
@@ -11220,7 +12215,7 @@ function createGenerateHandlers(opts) {
       if (!request.resume && !request.refresh && !request.restore && request.revert === void 0) {
         const plan = await buildPlan(specs, ctx.lock, { force: request.force });
         if (!plan.actionable.length) {
-          const reasons = plan.items.map((item) => `${item.key}: ${item.state} \u2014 ${item.reason}`).slice(0, 5);
+          const reasons = plan.items.map((item) => `${item.key}: ${item.state}, ${item.reason}`).slice(0, 5);
           throw new GenerateRequestError(`nothing to generate; ${reasons.join("; ")}`);
         }
         groups = plan.groups;
@@ -11301,15 +12296,15 @@ function createGenerateHandlers(opts) {
 }
 
 // src/gallery/editor.ts
-import { readFile as readFile20 } from "fs/promises";
-import path29 from "path";
+import { readFile as readFile21 } from "fs/promises";
+import path30 from "path";
 
 // src/editor/install.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync21 } from "fs";
-import { mkdir as mkdir8, readFile as readFile19, rename as rename8, rm as rm9, stat as stat3, writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync22 } from "fs";
+import { mkdir as mkdir9, readFile as readFile20, rename as rename8, rm as rm9, stat as stat3, writeFile as writeFile12 } from "fs/promises";
 import os2 from "os";
-import path28 from "path";
+import path29 from "path";
 
 // tools/pixelorama-bridge/pin.json
 var pin_default = {
@@ -11373,15 +12368,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return path28.resolve(override);
-  if (process.platform === "darwin") return path28.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return path29.resolve(override);
+  if (process.platform === "darwin") return path29.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return path28.join(process.env.LOCALAPPDATA ?? path28.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return path29.join(process.env.LOCALAPPDATA ?? path29.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return path28.join(process.env.XDG_CACHE_HOME ?? path28.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
+  return path29.join(process.env.XDG_CACHE_HOME ?? path29.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return path28.join(root, "pixelorama", pin.release ?? "unpublished");
+  return path29.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -11391,7 +12386,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return createHash4("sha256").update(await readFile19(file)).digest("hex");
+    return createHash4("sha256").update(await readFile20(file)).digest("hex");
   } catch {
     return null;
   }
@@ -11404,8 +12399,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = path28.join(dir, name);
-    const info = existsSync21(file) ? await stat3(file).catch(() => null) : null;
+    const file = path29.join(dir, name);
+    const info = existsSync22(file) ? await stat3(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -11434,7 +12429,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await mkdir8(dir, { recursive: true });
+  await mkdir9(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -11462,10 +12457,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 = path28.join(dir, name);
+    const final = path29.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await writeFile11(tmp, bytes);
+      await writeFile12(tmp, bytes);
       await rename8(tmp, final);
     } finally {
       await rm9(tmp, { force: true });
@@ -11508,7 +12503,7 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[path28.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[path29.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
@@ -11584,7 +12579,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await readFile20(path29.join(dir, name));
+        bytes = await readFile21(path30.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -11624,13 +12619,13 @@ async function serveUntilStopped(initial, reload, args, access2) {
   };
   const loadProject = async (project) => {
     const ctx = await access2.loadProject(project);
-    const dir = path30.dirname(ctx.loaded.path);
+    const dir = path31.dirname(ctx.loaded.path);
     const declared = readEnvFiles(dir);
     const credentialNames = new Set(availableProviders().flatMap((id) => providerCredentialEnvs(providerFactory(id))));
     for (const [name, value] of Object.entries(declared)) {
       if (credentialNames.has(name) && name in process.env && process.env[name] !== value) {
         throw new Error(
-          `${path30.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
+          `${path31.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
         );
       }
     }
@@ -11675,8 +12670,8 @@ async function serveUntilStopped(initial, reload, args, access2) {
 }
 async function runGallery(args) {
   if (args.workspace) {
-    const workspacePath = path30.resolve(args.workspace);
-    if (!existsSync22(workspacePath)) {
+    const workspacePath = path31.resolve(args.workspace);
+    if (!existsSync23(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const filter2 = { styles: args.styles, assets: args.assets };
@@ -11691,12 +12686,12 @@ async function runGallery(args) {
       return;
     }
     for (const project of initial.snapshot.workspace?.projects ?? []) {
-      if (project.error) log(`  ${project.id}: unreadable \u2014 ${project.error}`);
+      if (project.error) log(`  ${project.id}: unreadable: ${project.error}`);
     }
     const registered = async (projectId) => {
       const project = (await loadWorkspace(workspacePath)).projects.find((candidate) => candidate.id === projectId);
       if (!projectId || !project) throw new Error(`unknown workspace project "${projectId ?? ""}"`);
-      return resolveProject(path30.dirname(workspacePath), project);
+      return resolveProject(path31.dirname(workspacePath), project);
     };
     await serveUntilStopped(initial, build2, args, {
       manifestFor: async (projectId) => (await registered(projectId)).manifestPath,
@@ -11721,25 +12716,70 @@ async function runGallery(args) {
     return buildGallerySnapshot({ ...fresh, filter });
   };
   await serveUntilStopped(await build(), reload, args, {
-    manifestFor: () => path30.resolve(args.manifest),
+    manifestFor: () => path31.resolve(args.manifest),
     loadProject: () => openProject(args.manifest, { lockPath: args.lock, env: false })
   });
 }
 
 // src/cli/commands/generate.ts
 async function runGenerate(args) {
+  if (args.command !== "gen") {
+    await runLifecycle(args, 1, /* @__PURE__ */ new Map());
+    return;
+  }
+  const spent = /* @__PURE__ */ new Map();
+  for (let wave = 1; ; wave++) {
+    const again = await runLifecycle(args, wave, spent);
+    if (!again) return;
+  }
+}
+function remainingBudgets(args, spent) {
+  if (!spent.size) return args;
+  const total = [...spent.values()].reduce((sum, n) => sum + n, 0);
+  const providerBudgets = /* @__PURE__ */ Object.create(null);
+  for (const [provider, ceiling] of Object.entries(args.providerBudgets)) {
+    providerBudgets[provider] = Math.max(0, ceiling - (spent.get(provider) ?? 0));
+  }
+  return {
+    ...args,
+    ...args.budget === void 0 ? {} : { budget: Math.max(0, args.budget - total) },
+    providerBudgets
+  };
+}
+async function runLifecycle(args, wave, spent) {
   const { loaded, specs, lock } = await openProject2(args);
-  const plan = await buildPlan(specs, lock, { force: args.force });
+  const plan = await buildPlan(specs, lock, { force: args.force && wave === 1 });
   const providerFor = providerCache(providerModeFor(args));
+  let submitted = 0;
   if (args.command === "submit" || args.command === "gen") {
+    if (wave > 1) {
+      if (!plan.actionable.length) {
+        log(`
+  wave ${wave}: nothing else became actionable`);
+        return false;
+      }
+      log(`
+  wave ${wave}: ${plan.actionable.length} asset(s) became actionable`);
+    }
     printPlan(plan);
     if (args.dryRun) {
       log(`
   --dry-run: stopping before any spend.`);
-      return;
+      return false;
     }
     if (plan.actionable.length) {
-      const budgets = budgetsForPlan(plan, args);
+      let budgets;
+      try {
+        budgets = budgetsForPlan(plan, remainingBudgets(args, spent));
+      } catch (err) {
+        if (wave > 1 && err instanceof BudgetError) {
+          log(`
+  stopping before wave ${wave}: ${err.message}`);
+          log(`  run pixelkiln gen again with a budget for the remaining work`);
+          return false;
+        }
+        throw err;
+      }
       const balances = /* @__PURE__ */ new Map();
       for (const group of plan.groups) {
         const groupProvider = providerFor(group.provider);
@@ -11768,19 +12808,24 @@ async function runGenerate(args) {
         }
         const ceiling = budgets.get(group.provider);
         if (ceiling !== void 0 && group.cost > ceiling) {
-          throw new BudgetError(
-            `${group.provider} would spend ${formatCost(group.costUnit, group.cost)} but its budget is ${formatCost(group.costUnit, ceiling)}.`
-          );
+          const message6 = `${group.provider} would spend ${formatCost(group.costUnit, group.cost)} but ` + (wave > 1 ? `only ${formatCost(group.costUnit, ceiling)} of the budget is left after ${wave - 1} wave(s).` : `its budget is ${formatCost(group.costUnit, ceiling)}.`);
+          if (wave > 1) {
+            log(`
+  stopping before wave ${wave}: ${message6}`);
+            log(`  run pixelkiln gen again with a budget for the remaining work`);
+            return false;
+          }
+          throw new BudgetError(message6);
         }
       }
       const spendSummary = plan.groups.map((group) => `${group.provider} ${formatCost(group.costUnit, group.cost)}`).join("; ");
       const ok = await confirm(
-        `  Spend ${spendSummary} on ${plan.actionable.length} asset(s)?`,
+        `  Spend ${spendSummary} on ${plan.actionable.length} asset(s)${wave > 1 ? ` (wave ${wave})` : ""}?`,
         args.yes
       );
       if (!ok) {
         log(`  aborted`);
-        return;
+        return false;
       }
       log(`
   submitting\u2026`);
@@ -11794,6 +12839,8 @@ async function runGenerate(args) {
           `
   ${group.provider}: submitted ${res.submitted}, failed ${res.failed}, estimated ${formatCost(res.unit, res.spent)}`
         );
+        submitted += res.submitted;
+        spent.set(group.provider, (spent.get(group.provider) ?? 0) + res.spent);
         try {
           const before = balances.get(group.provider);
           const after = before && groupProvider.balance ? await groupProvider.balance() : null;
@@ -11813,7 +12860,7 @@ async function runGenerate(args) {
         if (res.failed) process.exitCode = 1;
       }
     }
-    if (args.command === "submit") return;
+    if (args.command === "submit") return false;
   }
   if (args.command === "poll" || args.command === "gen") {
     log(`
@@ -11836,7 +12883,7 @@ async function runGenerate(args) {
     if (total.failed || total.stillRunning) process.exitCode = 1;
     if (args.command === "poll") {
       printResumeActions(specs, lock);
-      return;
+      return false;
     }
   }
   if (args.command === "pick" || args.command === "gen") {
@@ -11862,7 +12909,7 @@ async function runGenerate(args) {
     if (args.command === "gen" && total.skipped) process.exitCode = 1;
     if (args.command === "pick") {
       printResumeActions(specs, lock);
-      return;
+      return false;
     }
   }
   if (args.command === "fetch" || args.command === "restore" || args.command === "gen") {
@@ -11912,8 +12959,9 @@ async function runGenerate(args) {
         log(`  Packaging stays blocked until each refined PNG has a current human approval.`);
       }
     }
-    return;
+    return args.command === "gen" && submitted > 0 && total.downloaded > 0 && !total.failed && specs.some((spec) => spec.character?.parentSpec || spec.revision);
   }
+  return false;
 }
 
 // src/cli/commands/history.ts
@@ -11973,18 +13021,18 @@ async function runRestoreGeneration(args) {
 }
 
 // src/cli/commands/housekeeping.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 
 // src/pipeline/cache-health.ts
-import { existsSync as existsSync23 } from "fs";
-import { readFile as readFile21, readdir as readdir2, rm as rm10 } from "fs/promises";
-import path31 from "path";
+import { existsSync as existsSync24 } from "fs";
+import { readFile as readFile22, readdir as readdir2, rm as rm10 } from "fs/promises";
+import path32 from "path";
 async function inspectCaches(lock, lockPath, options = {}) {
-  if (options.prune && !existsSync23(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path31.resolve(lockPath)}`);
+  if (options.prune && !existsSync24(lockPath)) {
+    throw new Error(`Refusing to prune without an existing lockfile at ${path32.resolve(lockPath)}`);
   }
-  const contentDir = path31.resolve(path31.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path31.resolve(cachePathFor(lockPath));
+  const contentDir = path32.resolve(path32.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path32.resolve(cachePathFor(lockPath));
   const referenced = referencedHashes(lock);
   let content = await inspectContentCache(contentDir, referenced);
   let remoteHashes = await inspectRemoteHashCache(remotePath);
@@ -11996,7 +13044,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm10(path31.join(contentDir, name), { force: true });
+        await rm10(path32.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -12005,7 +13053,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
       await saveCache(remotePath, { version: 1, hashes: {} });
       removed.resetRemoteHashCache = true;
     } else if (remoteHashes.invalidIds.length) {
-      const cache = parseCache(JSON.parse(await readFile21(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile22(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -12023,7 +13071,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
 async function inspectContentCache(contentDir, referenced) {
   const report = {
     path: contentDir,
-    exists: existsSync23(contentDir),
+    exists: existsSync24(contentDir),
     files: 0,
     bytes: 0,
     valid: 0,
@@ -12044,12 +13092,12 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path31.join(contentDir, entry.name);
+    const file = path32.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile21(file);
+      bytes = await readFile22(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -12087,7 +13135,7 @@ async function inspectContentCache(contentDir, referenced) {
 async function inspectRemoteHashCache(remotePath) {
   const report = {
     path: remotePath,
-    exists: existsSync23(remotePath),
+    exists: existsSync24(remotePath),
     entries: 0,
     valid: 0,
     invalidIds: [],
@@ -12096,7 +13144,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile21(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile22(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -12120,7 +13168,7 @@ async function runCache(args) {
     const size = report.content.bytes < 1024 ? `${report.content.bytes} B` : `${(report.content.bytes / 1024).toFixed(1)} KB`;
     log(`  content cache: ${report.content.path}`);
     log(
-      report.content.exists ? `    ${report.content.valid} valid PNG(s), ${report.content.referenced} referenced, ${report.content.unreferenced.length} unreferenced \u2014 ${size}` : "    not created yet"
+      report.content.exists ? `    ${report.content.valid} valid PNG(s), ${report.content.referenced} referenced, ${report.content.unreferenced.length} unreferenced, ${size}` : "    not created yet"
     );
     if (report.content.missingReferenced.length) {
       log(`    ${report.content.missingReferenced.length} lockfile hash(es) are not locally cached`);
@@ -12160,7 +13208,7 @@ async function runAccept(args) {
     let intact = true;
     for (const output of entry.outputs) {
       const file = resolveOutputPath(output.path, item.spec.root);
-      if (!existsSync24(file) || await sha256File(file) !== output.sha256) {
+      if (!existsSync25(file) || await sha256File(file) !== output.sha256) {
         intact = false;
         break;
       }
@@ -12183,7 +13231,7 @@ async function runPrune(args) {
   const declared = new Set((await resolveSpecs(loaded)).map((s) => lockKey(s.styleId, s.assetId)));
   const orphans = Object.keys(lock.entries).filter((key) => !declared.has(key)).sort();
   if (!orphans.length) {
-    log(`  every lock entry is declared by the manifest \u2014 nothing to prune`);
+    log(`  every lock entry is declared by the manifest; nothing to prune`);
     return;
   }
   log(`
@@ -12201,7 +13249,7 @@ ${orphans.length} lock entr(ies) the manifest no longer declares:`);
   }
   log(`
 This drops their provenance from the lockfile. The art on disk is`);
-  log(`  untouched, and nothing is deleted from your provider account \u2014 but`);
+  log(`  untouched, and nothing is deleted from your provider account, but`);
   log(`  the link from those files back to the objects that made them is gone,`);
   log(`  and the objects will read as unclaimed the next time you run salvage.`);
   if (!await confirm(`  Remove ${orphans.length} lock entr(ies)?`, args.yes)) {
@@ -12215,42 +13263,42 @@ This drops their provenance from the lockfile. The art on disk is`);
 }
 
 // src/cli/commands/init.ts
-import path32 from "path";
-import { existsSync as existsSync25 } from "fs";
+import path33 from "path";
+import { existsSync as existsSync26 } from "fs";
 async function runInit(args) {
   if (!args.from) throw new Error("init needs --from <dir> pointing at your existing PNGs.");
-  const root = path32.resolve(args.from);
-  if (!existsSync25(root)) throw new Error(`No directory at ${root}`);
+  const root = path33.resolve(args.from);
+  if (!existsSync26(root)) throw new Error(`No directory at ${root}`);
   const generator = args.generator ?? "map";
   if (generator !== "1dir" && generator !== "map") {
     throw new Error(`--generator must be "1dir" or "map", got "${args.generator}".`);
   }
-  const target = path32.resolve(args.out ?? "pixelkiln.manifest.json");
+  const target = path33.resolve(args.out ?? "pixelkiln.manifest.json");
   const { assets, skipped } = await scanAssets(root, { exclude: args.exclude });
   if (!assets.length) throw new Error(`No PNGs found under ${root}`);
   const manifest = buildManifest(
-    args.name ?? path32.basename(path32.dirname(target)),
+    args.name ?? path33.basename(path33.dirname(target)),
     args.styles[0] ?? "base",
     generator,
-    path32.relative(path32.dirname(target), root) || ".",
+    path33.relative(path33.dirname(target), root) || ".",
     assets
   );
   await writeManifestFile(target, manifest);
-  log(`  scanned ${assets.length} PNG(s) under ${path32.relative(process.cwd(), root)}`);
+  log(`  scanned ${assets.length} PNG(s) under ${path33.relative(process.cwd(), root)}`);
   if (skipped.length) log(`  skipped ${skipped.length} unreadable file(s)`);
-  log(`  wrote ${path32.relative(process.cwd(), target)}`);
+  log(`  wrote ${path33.relative(process.cwd(), target)}`);
   log(`
   Prompts are intentionally empty. To recover the real ones from your`);
   log(`  PixelLab account instead of inventing them:`);
   log(`
-    pixelkiln adopt --manifest ${path32.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path33.relative(process.cwd(), target)} --write-prompts
 `);
 }
 
 // src/pipeline/doctor.ts
-import { constants, existsSync as existsSync26 } from "fs";
+import { constants, existsSync as existsSync27 } from "fs";
 import { access, stat as stat4 } from "fs/promises";
-import path33 from "path";
+import path34 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message6) => checks.push({ id, level, message: message6 });
@@ -12261,8 +13309,8 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   );
   add("lock", "ok", `${Object.keys(lock.entries).length} valid v2 lock entr(ies)`);
   const dirs = [...new Set(specs.flatMap((spec) => [
-    path33.dirname(spec.outFile),
-    ...spec.quality ? [path33.dirname(spec.quality.outFile)] : []
+    path34.dirname(spec.outFile),
+    ...spec.quality ? [path34.dirname(spec.quality.outFile)] : []
   ]))];
   const unwritable = [];
   for (const dir of dirs) {
@@ -12285,7 +13333,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     for (let index = 0; index < entry.outputs.length; index++) {
       const output = entry.outputs[index];
       const spec = specByKey.get(key);
-      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path33.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path34.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -12295,12 +13343,12 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     add(
       "lock-outputs",
       "error",
-      `lock entries share output paths: ${duplicateOutputs.slice(0, 3).join(", ")}${duplicateOutputs.length > 3 ? `, and ${duplicateOutputs.length - 3} more` : ""} \u2014 run \`pixelkiln prune\` if the manifest no longer declares them`
+      `lock entries share output paths: ${duplicateOutputs.slice(0, 3).join(", ")}${duplicateOutputs.length > 3 ? `, and ${duplicateOutputs.length - 3} more` : ""}; run \`pixelkiln prune\` if the manifest no longer declares them`
     );
   } else {
     add("lock-outputs", "ok", `${outputOwners.size} recorded output path(s) are uniquely owned`);
   }
-  const cacheDir = path33.join(path33.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = path34.join(path34.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -12316,11 +13364,11 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     const hasSource = Boolean(entry.sourceUrl || entry.sourceUrls?.length);
     let hasCache = false;
     for (const output of entry.outputs) {
-      const cached = path33.join(
+      const cached = path34.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
-      if (existsSync26(cached) && await sha256File(cached) === output.sha256) {
+      if (existsSync27(cached) && await sha256File(cached) === output.sha256) {
         hasCache = true;
         break;
       }
@@ -12416,16 +13464,16 @@ async function nearestExistingDirectory(start) {
       if ((await stat4(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = path33.dirname(current);
+    const parent = path34.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
 }
 
 // src/pipeline/audit.ts
-import { readFile as readFile22 } from "fs/promises";
-import { existsSync as existsSync27 } from "fs";
-import path34 from "path";
+import { readFile as readFile23 } from "fs/promises";
+import { existsSync as existsSync28 } from "fs";
+import path35 from "path";
 function paletteDistance(asset, reference) {
   if (!asset.length || !reference.length) return 0;
   let total = 0;
@@ -12461,12 +13509,12 @@ async function auditStyle(loaded, specs, styleId, lock) {
   const unreadable = [];
   for (const spec of mine) {
     for (const output of resolveSpecOutputs(spec, lock, loaded.root)) {
-      if (!existsSync27(output.absolutePath)) {
+      if (!existsSync28(output.absolutePath)) {
         missing.push(output.id);
         continue;
       }
       try {
-        const png = decodePng(await readFile22(output.absolutePath));
+        const png = decodePng(await readFile23(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -12490,10 +13538,10 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = path34.resolve(loaded.root, img.path);
-    if (!existsSync27(abs)) continue;
+    const abs = path35.resolve(loaded.root, img.path);
+    if (!existsSync28(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await readFile22(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await readFile23(abs)), 12));
     } catch {
     }
   }
@@ -12677,12 +13725,12 @@ async function runAudit(args) {
     reports.push({ audit, evaluation });
     if (args.json) continue;
     log(`
-  ${styleId} \u2014 ${audit.assets.length} asset(s) measured`);
+  ${styleId}: ${audit.assets.length} asset(s) measured`);
     log(
       `  reference palette: ${audit.referenceFromStyleImages ? "style images" : "the set's own average"}  ${audit.reference.slice(0, 6).map(hex).join(" ")}`
     );
     if (!audit.referenceFromStyleImages) {
-      log(`  (no styleImages set \u2014 this finds outliers but cannot tell you the whole set drifted)`);
+      log(`  (no styleImages set; this finds outliers but cannot tell you the whole set drifted)`);
     }
     const offIds = new Set(evaluation.outliers);
     log(`
@@ -12713,24 +13761,24 @@ async function runAudit(args) {
 }
 
 // src/cli/commands/pack.ts
-import path36 from "path";
-import { readFile as readFile23 } from "fs/promises";
+import path37 from "path";
+import { readFile as readFile24 } from "fs/promises";
 
 // src/pipeline/pack.ts
 import { readFileSync as readFileSync5 } from "fs";
-import path35 from "path";
+import path36 from "path";
 var DEFAULT_FRAME_SET_FPS = 12;
 function resolvePackInputs(raw, inputsFilePath) {
   if (!Array.isArray(raw) || !raw.length) {
     throw new Error("--inputs must be a non-empty JSON array of { id, path }");
   }
-  const baseDir = path35.dirname(path35.resolve(inputsFilePath));
+  const baseDir = path36.dirname(path36.resolve(inputsFilePath));
   return raw.map((entry, i) => {
     const e = entry;
     if (typeof e.id !== "string" || typeof e.path !== "string") {
       throw new Error(`--inputs[${i}] needs string "id" and "path"`);
     }
-    return { id: e.id, path: path35.resolve(baseDir, e.path) };
+    return { id: e.id, path: path36.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -12762,7 +13810,7 @@ function packSprites(inputs, options = {}) {
     }
   }
   if (!sprites.length) {
-    throw new Error(`packSprites: nothing readable \u2014 ${skipped.length} skipped.`);
+    throw new Error(`packSprites: nothing readable; ${skipped.length} skipped.`);
   }
   const cellW = Math.max(...sprites.map((s) => s.width));
   const cellH = Math.max(...sprites.map((s) => s.height));
@@ -12802,7 +13850,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
     const inputs2 = Object.entries(options.sourceOverrides).map(([id, source]) => ({
       id,
-      path: path35.resolve(source)
+      path: path36.resolve(source)
     }));
     if (!inputs2.length) throw new Error(`No approved quality outputs for style "${styleId}".`);
     const packed2 = packSprites(inputs2, options);
@@ -12826,7 +13874,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     let outputs = resolveEntryOutputs(entry, id, manifestDir);
     const source = sources[id];
     if (source && outputs.length <= 1) {
-      inputs.push({ id, path: path35.resolve(manifestDir, source) });
+      inputs.push({ id, path: path36.resolve(manifestDir, source) });
       continue;
     }
     if (source && sourceIsStem(source, entry, manifestDir)) {
@@ -12848,20 +13896,22 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
     for (const output of selected) inputs.push({ id: output.id, path: output.absolutePath });
     if (entry.outputs.length > 1) {
-      const fps = entry.generator === "frames" ? frameSetFps(entry) ?? DEFAULT_FRAME_SET_FPS : null;
+      const recordedFps = frameSetFps(entry);
+      const isFrames = entry.generator === "frames" || recordedFps !== null;
+      const fps = isFrames ? recordedFps ?? DEFAULT_FRAME_SET_FPS : null;
       sets.push({
         id,
-        kind: entry.generator === "frames" ? "frames" : "members",
+        kind: isFrames ? "frames" : "members",
         ...fps ? { fps } : {},
         frames: selected.map((output) => output.id)
       });
     }
   }
   for (const [id, source] of Object.entries(sources)) {
-    if (!locked.has(id)) inputs.push({ id, path: path35.resolve(manifestDir, source) });
+    if (!locked.has(id)) inputs.push({ id, path: path36.resolve(manifestDir, source) });
   }
   if (!inputs.length) {
-    throw new Error(`No readable sprites for style "${styleId}" \u2014 ${noOutput.length} skipped.`);
+    throw new Error(`No readable sprites for style "${styleId}"; ${noOutput.length} skipped.`);
   }
   const packed = packSprites(inputs, options);
   const packedIds = new Set(packed.atlas.frames.map((frame) => frame.id));
@@ -12884,7 +13934,7 @@ function mountSprites(placements, options) {
     const owner = byCell.get(key);
     if (owner) {
       throw new Error(
-        `mountSprites: "${p.id}" and "${owner}" both claim cell ${key} \u2014 a cell has exactly one owner`
+        `mountSprites: "${p.id}" and "${owner}" both claim cell ${key}; a cell has exactly one owner`
       );
     }
     byCell.set(key, p.id);
@@ -12911,7 +13961,7 @@ function mountSprites(placements, options) {
     }
   }
   if (!loaded.length) {
-    throw new Error(`mountSprites: nothing readable \u2014 ${skipped.length} skipped.`);
+    throw new Error(`mountSprites: nothing readable; ${skipped.length} skipped.`);
   }
   const maxCol = Math.max(...loaded.map((l) => l.p.cell[0]));
   const maxRow = Math.max(...loaded.map((l) => l.p.cell[1]));
@@ -12966,7 +14016,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     const source = sources[id];
     const entry = lock.entries[`${styleId}/${id}`];
     if (source && !(entry && sourceIsStem(source, entry, manifestDir))) {
-      placements.push({ id, path: path35.resolve(manifestDir, source), cell });
+      placements.push({ id, path: path36.resolve(manifestDir, source), cell });
       continue;
     }
     if (source && entry) {
@@ -12999,7 +14049,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
       `Nothing to mount for style "${styleId}": ${ids.length} asset(s) declare a cell, but none has generated output or a \`source\`. Run \`pixelkiln gen --style ${styleId}\`, or point each at a file.${detail}`
     );
   }
-  const basePng = mount.base ? readFileSync5(path35.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? readFileSync5(path36.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -13009,7 +14059,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: path35.resolve(manifestDir, mount.base),
+      path: path36.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -13376,12 +14426,12 @@ async function runPack(args) {
     if (args.primaryOnly || args.outputRoles.length) {
       throw new Error("--primary-only and --output-role require manifest-driven pack");
     }
-    const raw = JSON.parse(await readFile23(path36.resolve(args.inputs), "utf8"));
+    const raw = JSON.parse(await readFile24(path37.resolve(args.inputs), "utf8"));
     const inputs = resolvePackInputs(raw, args.inputs);
     const { png, atlas, skipped, sources } = packSprites(inputs, { columns: args.columns });
     const format = sheetFormat(args);
-    const base = path36.resolve(args.out.replace(/\.(?:png|json|tres)$/i, ""));
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path36.basename(`${base}.png`) });
+    const base = path37.resolve(args.out.replace(/\.(?:png|json|tres)$/i, ""));
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path37.basename(`${base}.png`) });
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}${extension}`, data: document }
@@ -13392,9 +14442,9 @@ async function runPack(args) {
       options: { columns: args.columns ?? null, format, order: "id", style: null }
     }, { force: args.force });
     log(
-      `  ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s) \u2014 ${(png.length / 1024).toFixed(1)} KB (${format})`
+      `  ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s), ${(png.length / 1024).toFixed(1)} KB (${format})`
     );
-    log(`    ${path36.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
+    log(`    ${path37.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     return;
   }
@@ -13402,7 +14452,7 @@ async function runPack(args) {
   if (args.primaryOnly && args.outputRoles.length) {
     throw new Error("pack accepts either --primary-only or --output-role, not both");
   }
-  const manifestDir = path36.dirname(path36.resolve(args.manifest));
+  const manifestDir = path37.dirname(path37.resolve(args.manifest));
   const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
   for (const styleId of styleIds) {
     const packagingSpecs = await resolveSpecs(loaded, { styles: [styleId] });
@@ -13415,9 +14465,9 @@ async function runPack(args) {
       sources: manifestSources(loaded.manifest, styleId)
     });
     const style = loaded.manifest.styles[styleId];
-    const base = args.out ? path36.resolve(args.out.replace(/\.(?:png|json|tres)$/i, "")) : path36.resolve(manifestDir, style.outDir, `${styleId}-sheet`);
+    const base = args.out ? path37.resolve(args.out.replace(/\.(?:png|json|tres)$/i, "")) : path37.resolve(manifestDir, style.outDir, `${styleId}-sheet`);
     const format = sheetFormat(args);
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path36.basename(`${base}.png`) });
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path37.basename(`${base}.png`) });
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}${extension}`, data: document }
@@ -13446,15 +14496,15 @@ async function runPack(args) {
       }
     }, { force: args.force });
     log(
-      `  ${styleId} \u2014 ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s)` + (atlas.sets?.length ? `, ${atlas.sets.length} set(s)` : "") + ` (${format})`
+      `  ${styleId}: ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s)` + (atlas.sets?.length ? `, ${atlas.sets.length} set(s)` : "") + ` (${format})`
     );
-    log(`    ${path36.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
+    log(`    ${path37.relative(process.cwd(), base)}.png + ${extension} + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
   }
 }
 async function runMount(args) {
   const { loaded, lock } = await openProject2(args);
-  const manifestDir = path36.dirname(path36.resolve(args.manifest));
+  const manifestDir = path37.dirname(path37.resolve(args.manifest));
   const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
   for (const styleId of styleIds) {
     const style = loaded.manifest.styles[styleId];
@@ -13493,9 +14543,9 @@ async function runMount(args) {
       sources,
       outputRoles
     );
-    const out = path36.resolve(manifestDir, style.mount.out);
+    const out = path37.resolve(manifestDir, style.mount.out);
     const format = sheetFormat(args);
-    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path36.basename(out) });
+    const { extension, document } = renderSheetDocument(format, atlas, { imageName: path37.basename(out) });
     const metadata = out.replace(/\.png$/, "") + extension;
     const companion = out.replace(/\.png$/, "") + ".pixelkiln.json";
     const outputs = [
@@ -13515,7 +14565,7 @@ async function runMount(args) {
         await provenanceFile("$lock", args.lock),
         ...qualityRecords,
         ...artifactSources.filter(
-          (source) => source.id !== "$base" || path36.resolve(source.path) !== out
+          (source) => source.id !== "$base" || path37.resolve(source.path) !== out
         )
       ],
       options: {
@@ -13527,16 +14577,16 @@ async function runMount(args) {
       }
     }, { force: args.force });
     log(
-      `  ${styleId} \u2014 ${atlas.frames.length} cell(s) into ${atlas.sheet.width}x${atlas.sheet.height}` + (overBase ? ` over ${style.mount.base}` : " (new sheet)")
+      `  ${styleId}: ${atlas.frames.length} cell(s) into ${atlas.sheet.width}x${atlas.sheet.height}` + (overBase ? ` over ${style.mount.base}` : " (new sheet)")
     );
-    log(`    ${path36.relative(process.cwd(), out)} + atlas/provenance JSON`);
+    log(`    ${path37.relative(process.cwd(), out)} + atlas/provenance JSON`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
   }
 }
 async function runExport(args) {
   const { loaded, specs, lock } = await openProject2(args);
   const format = args.format ?? "generic";
-  const manifestDir = path36.dirname(path36.resolve(args.manifest));
+  const manifestDir = path37.dirname(path37.resolve(args.manifest));
   const selected = specs.filter((spec) => {
     if (spec.generator !== "tiles") return false;
     if (args.styles.length && !args.styles.includes(spec.styleId)) return false;
@@ -13552,12 +14602,12 @@ async function runExport(args) {
   for (const spec of selected) {
     const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
     const style = loaded.manifest.styles[spec.styleId];
-    const defaultBase = path36.resolve(manifestDir, style.outDir, `${spec.assetId}-tileset`);
-    const base = args.out ? path36.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
+    const defaultBase = path37.resolve(manifestDir, style.outDir, `${spec.assetId}-tileset`);
+    const base = args.out ? path37.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
     const result = exportTileset(entry, spec, {
       format,
       manifestDir,
-      imageName: path36.basename(`${base}.png`),
+      imageName: path37.basename(`${base}.png`),
       columns: args.columns
     });
     const outputs = [
@@ -13575,17 +14625,17 @@ async function runExport(args) {
         asset: spec.assetId,
         columns: args.columns ?? null,
         format,
-        image: path36.basename(`${base}.png`),
+        image: path37.basename(`${base}.png`),
         providerRules: result.generic.providerRules,
         style: spec.styleId,
         tileType: spec.tileType ?? null
       }
     }, { force: args.force });
     log(
-      `  ${spec.styleId}/${spec.assetId} \u2014 ${result.generic.tiles.length} tile(s), ${result.generic.sheet.width}x${result.generic.sheet.height} (${format})`
+      `  ${spec.styleId}/${spec.assetId}: ${result.generic.tiles.length} tile(s), ${result.generic.sheet.width}x${result.generic.sheet.height} (${format})`
     );
     log(
-      `    ${path36.relative(process.cwd(), base)}.png + ${path36.basename(base)}${result.extension} + .pixelkiln.json`
+      `    ${path37.relative(process.cwd(), base)}.png + ${path37.basename(base)}${result.extension} + .pixelkiln.json`
     );
   }
 }
@@ -13598,19 +14648,19 @@ function sheetFormat(args) {
 }
 
 // src/cli/commands/quality.ts
-import path38 from "path";
-import { readFile as readFile25 } from "fs/promises";
+import path39 from "path";
+import { readFile as readFile26 } from "fs/promises";
 
 // src/pipeline/quality-regression.ts
-import path37 from "path";
-import { existsSync as existsSync28 } from "fs";
-import { readFile as readFile24 } from "fs/promises";
+import path38 from "path";
+import { existsSync as existsSync29 } from "fs";
+import { readFile as readFile25 } from "fs/promises";
 import { z as z9 } from "zod";
 var SHA256_RE = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
 var QualityPathSchema = z9.string().min(1).refine(
-  (value) => !path37.posix.isAbsolute(value) && !value.includes("\\"),
+  (value) => !path38.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -13757,10 +14807,10 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = path37.resolve(file);
+  const absolute = path38.resolve(file);
   let bytes;
   try {
-    bytes = await readFile24(absolute);
+    bytes = await readFile25(absolute);
   } catch (error) {
     throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -13779,11 +14829,11 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }
   const ids = parsed.data.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) throw new Error("--inputs contains a duplicate quality case id.");
-  const root = path37.dirname(path37.resolve(inputsFilePath));
+  const root = path38.dirname(path38.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: path37.resolve(root, entry.path),
-    ...entry.record ? { record: path37.resolve(root, entry.record) } : {},
+    file: path38.resolve(root, entry.path),
+    ...entry.record ? { record: path38.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -13791,7 +14841,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return path37.relative(from, path37.resolve(to)).split(path37.sep).join("/") || ".";
+  return path38.relative(from, path38.resolve(to)).split(path38.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -13806,20 +14856,20 @@ async function verifyRecordForImage(recordPath, imagePath) {
   if (record.kind !== "refine" || options === null || typeof options !== "object" || options.schema !== "pixelkiln-quality") {
     throw new Error(`Quality record ${recordPath} is not a PixelKiln refinement record.`);
   }
-  const outputs = record.outputs.map((output) => path37.resolve(path37.dirname(recordPath), output.path));
-  if (!outputs.includes(path37.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => path38.resolve(path38.dirname(recordPath), output.path));
+  if (!outputs.includes(path38.resolve(imagePath))) {
     throw new Error(`Quality record ${recordPath} does not own ${imagePath}.`);
   }
 }
 async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   if (!inputs.length) throw new Error("Cannot snapshot an empty quality baseline.");
-  const absolute = path37.resolve(baselinePath);
+  const absolute = path38.resolve(baselinePath);
   for (const input of inputs) {
-    if (path37.resolve(input.file) === absolute || input.record && path37.resolve(input.record) === absolute) {
+    if (path38.resolve(input.file) === absolute || input.record && path38.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = path37.dirname(absolute);
+  const root = path38.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -13846,8 +14896,8 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
     cases
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
-  if (existsSync28(absolute) && !options.force) {
-    const current = await readFile24(absolute);
+  if (existsSync29(absolute) && !options.force) {
+    const current = await readFile25(absolute);
     if (!current.equals(data)) {
       throw new OverwriteRefusedError(
         `Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`,
@@ -13859,10 +14909,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = path37.resolve(baselinePath);
+  const absolute = path38.resolve(baselinePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile24(absolute, "utf8"));
+    raw = JSON.parse(await readFile25(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -13932,12 +14982,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = path37.resolve(baselinePath);
+  const absolute = path38.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = path37.dirname(absolute);
+  const root = path38.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = path37.resolve(root, entry.file);
+    const file = path38.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -13950,7 +15000,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = path37.resolve(root, entry.record.path);
+      const recordPath = path38.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -13992,15 +15042,15 @@ async function runQuality(args) {
     if (!args.out) throw new Error("quality snapshot needs --out <pixelkiln.quality.json>.");
     let raw;
     try {
-      raw = JSON.parse(await readFile25(path38.resolve(args.inputs), "utf8"));
+      raw = JSON.parse(await readFile26(path39.resolve(args.inputs), "utf8"));
     } catch (error) {
       throw new Error(
-        `Could not read quality inputs ${path38.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
+        `Could not read quality inputs ${path39.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
         { cause: error }
       );
     }
     const inputs = resolveQualityInputs(raw, args.inputs);
-    if (path38.resolve(args.inputs) === path38.resolve(args.out)) {
+    if (path39.resolve(args.inputs) === path39.resolve(args.out)) {
       throw new Error("quality snapshot --out must not overwrite its --inputs file.");
     }
     const result = await snapshotQualityBaseline(inputs, args.out, { force: args.force });
@@ -14013,7 +15063,7 @@ async function runQuality(args) {
       }, null, 2));
     } else {
       log(
-        `  ${result.changed ? "wrote" : "unchanged"} ${path38.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
+        `  ${result.changed ? "wrote" : "unchanged"} ${path39.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
       );
       log(`  Review the tolerances, commit the baseline, then run quality check in CI.`);
     }
@@ -14039,12 +15089,12 @@ async function runQuality(args) {
 }
 
 // src/cli/commands/recipe.ts
-import path40 from "path";
+import path41 from "path";
 
 // src/recipes.ts
-import path39 from "path";
-import { existsSync as existsSync29 } from "fs";
-import { readdir as readdir3, readFile as readFile26 } from "fs/promises";
+import path40 from "path";
+import { existsSync as existsSync30 } from "fs";
+import { readdir as readdir3, readFile as readFile27 } from "fs/promises";
 import { fileURLToPath } from "url";
 import { z as z10 } from "zod";
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
@@ -14053,7 +15103,7 @@ var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
 var PortablePathSchema = z10.string().min(1).refine((value) => {
-  if (value.includes("\\") || path39.posix.isAbsolute(value)) return false;
+  if (value.includes("\\") || path40.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
@@ -14229,10 +15279,10 @@ function message5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path39.resolve(recipePath);
+  const absolute = path40.resolve(recipePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile26(absolute, "utf8"));
+    raw = JSON.parse(await readFile27(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read recipe ${absolute}: ${message5(error)}`, { cause: error });
   }
@@ -14243,13 +15293,13 @@ async function readRecipeFile(recipePath, bundled) {
 ` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
     );
   }
-  return { recipe: parsed.data, authored: raw, path: absolute, dir: path39.dirname(absolute), bundled };
+  return { recipe: parsed.data, authored: raw, path: absolute, dir: path40.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
-  if (!existsSync29(root)) return [];
+  if (!existsSync30(root)) return [];
   const out = [];
   for (const entry of await readdir3(root, { withFileTypes: true })) {
-    const resolved = path39.join(root, entry.name);
+    const resolved = path40.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -14260,7 +15310,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path39.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path40.resolve(root))).map((file) => readRecipeFile(file, true))
   );
   return recipes.sort(
     (a, b) => a.recipe.id.localeCompare(b.recipe.id) || compareVersions(b.recipe.version, a.recipe.version)
@@ -14283,9 +15333,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path39.resolve(target);
-  if (existsSync29(local)) {
-    const recipePath = path39.basename(local) === RECIPE_FILE ? local : path39.join(local, RECIPE_FILE);
+  const local = path40.resolve(target);
+  if (existsSync30(local)) {
+    const recipePath = path40.basename(local) === RECIPE_FILE ? local : path40.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -14299,8 +15349,8 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path39.resolve(root, ...file.path.split("/"));
-  if (!existsSync29(absolute)) {
+  const absolute = path40.resolve(root, ...file.path.split("/"));
+  if (!existsSync30(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
   const actualSha256 = await sha256File(absolute);
@@ -14315,7 +15365,7 @@ async function verifyRecipe(target, options = {}) {
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const actualIntegrity = recipeDigest(loaded.authored);
   const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
-  const modelRoot = options.modelRoot ? path39.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path40.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -14349,7 +15399,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path39.relative(cwd, destination).split(path39.sep).join("/") || ".";
+  const portableDir = path40.relative(cwd, destination).split(path40.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -14361,25 +15411,25 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path39.resolve(options.cwd ?? process.cwd());
+  const cwd = path40.resolve(options.cwd ?? process.cwd());
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const verification = await verifyRecipe(loaded.path);
   if (!verification.ok) {
     throw new Error(`Recipe ${loaded.recipe.id}@${loaded.recipe.version} failed integrity verification.`);
   }
-  const destination = options.out ? path39.resolve(cwd, options.out) : path39.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path40.resolve(cwd, options.out) : path40.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
   const sources = [
     { path: RECIPE_FILE, source: loaded.path },
-    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path39.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path40.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path39.join(destination, ...file.path.split("/")),
-    data: await readFile26(file.source)
+    path: path40.join(destination, ...file.path.split("/")),
+    data: await readFile27(file.source)
   })));
   if (!options.force) {
     for (const file of files) {
-      if (!existsSync29(file.path)) continue;
-      const current = await readFile26(file.path);
+      if (!existsSync30(file.path)) continue;
+      const current = await readFile27(file.path);
       if (!current.equals(file.data)) {
         throw new OverwriteRefusedError(
           `Recipe destination has local changes: ${file.path}. Choose another --out or pass --force to replace declared recipe files.`,
@@ -14473,14 +15523,14 @@ async function runRecipe(args) {
       }, null, 2));
     } else {
       log(`  installed ${result.recipe.id}@${result.recipe.version}`);
-      log(`  ${path40.relative(process.cwd(), result.destination) || "."}`);
+      log(`  ${path41.relative(process.cwd(), result.destination) || "."}`);
       log(`
   Add this entry under your manifest's styles object:`);
       log(JSON.stringify({ [result.styleId]: result.style }, null, 2));
       if (result.recipe.models.length) {
         log(`
   Models are not downloaded automatically. Verify them with:`);
-        log(`  pixelkiln recipe verify ${path40.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
+        log(`  pixelkiln recipe verify ${path41.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
       }
     }
     return;
@@ -14488,7 +15538,7 @@ async function runRecipe(args) {
 }
 
 // src/cli/commands/refine.ts
-import path41 from "path";
+import path42 from "path";
 async function runRefine(args) {
   if (args.from || args.subcommand === "approve") {
     if (!args.from) {
@@ -14518,12 +15568,12 @@ async function runRefine(args) {
           `  recovered ${result3.detection.columns}x${result3.detection.rows} native grid (${result3.detection.confidence}: ${result3.detection.consensus})`
         );
         log(`  enforced ${result3.palette.length}-color palette without dithering`);
-        log(`  wrote ${path41.relative(process.cwd(), result3.output)}`);
-        log(`  quality record: ${path41.relative(process.cwd(), result3.record)}`);
+        log(`  wrote ${path42.relative(process.cwd(), result3.output)}`);
+        log(`  quality record: ${path42.relative(process.cwd(), result3.record)}`);
         log(`
   Automated checks passed. Human 1\xD7 review is still required:`);
         log(
-          `    pixelkiln refine approve --from ${path41.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path42.relative(process.cwd(), result3.record)} --reviewer "Your Name"`
         );
       }
       return;
@@ -14551,7 +15601,7 @@ async function runRefine(args) {
       if (args.json) log(JSON.stringify(result3, null, 2));
       else {
         log(
-          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path41.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path41.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
+          result3.options.frameSet ? `  approved ${result3.outputs.length} frames in ${path42.relative(process.cwd(), result3.record)} by ${args.reviewer.trim()}` : `  approved ${path42.relative(process.cwd(), result3.output)} by ${args.reviewer.trim()}`
         );
       }
       return;
@@ -14560,7 +15610,7 @@ async function runRefine(args) {
     if (args.json) {
       log(JSON.stringify(result2, null, 2));
     } else {
-      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path41.relative(process.cwd(), result2.output || result2.record)}`);
+      log(`  ${result2.safe ? "release-ready" : "not release-ready"}: ${path42.relative(process.cwd(), result2.output || result2.record)}`);
       for (const reason of result2.reasons) log(`    ${reason}`);
     }
     if (!result2.safe) process.exitCode = 1;
@@ -14606,7 +15656,7 @@ async function runRefine(args) {
       log(`  ${item.state.padEnd(16)} ${item.key}  ${item.reason}`);
       if (item.state === "needs-approval") {
         log(
-          `    pixelkiln refine approve --from ${path41.relative(process.cwd(), item.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path42.relative(process.cwd(), item.record)} --reviewer "Your Name"`
         );
       }
     }
@@ -14631,7 +15681,7 @@ async function runTools(args) {
       return;
     }
     log(`          release ${status2.release}`);
-    log(`          ${status2.installed ? "installed and verified" : status2.installedBytes ? `partial: ${status2.missing.length} of ${Object.keys(EDITOR_PIN.files).length} files missing` : "not installed"} \u2014 ${mb(status2.totalBytes)} in ${status2.dir}`);
+    log(`          ${status2.installed ? "installed and verified" : status2.installedBytes ? `partial: ${status2.missing.length} of ${Object.keys(EDITOR_PIN.files).length} files missing` : "not installed"}, ${mb(status2.totalBytes)} in ${status2.dir}`);
     if (!status2.installed) log("          run: pixelkiln tools install editor");
     return;
   }
@@ -14658,15 +15708,15 @@ async function runTools(args) {
 }
 
 // src/cli/commands/workspace.ts
-import path42 from "path";
-import { existsSync as existsSync30 } from "fs";
+import path43 from "path";
+import { existsSync as existsSync31 } from "fs";
 async function runWorkspace(args) {
-  const workspacePath = path42.resolve(args.workspace ?? "pixelkiln.workspace.json");
-  const dir = path42.dirname(workspacePath);
+  const workspacePath = path43.resolve(args.workspace ?? "pixelkiln.workspace.json");
+  const dir = path43.dirname(workspacePath);
   if (args.subcommand === "add") {
-    const manifestPath = path42.resolve(args.target);
+    const manifestPath = path43.resolve(args.target);
     const loadedTarget = await loadManifest(manifestPath);
-    const lockPath = args.explicitLock ? path42.resolve(args.explicitLock) : path42.join(path42.dirname(manifestPath), "pixelkiln.lock.json");
+    const lockPath = args.explicitLock ? path43.resolve(args.explicitLock) : path43.join(path43.dirname(manifestPath), "pixelkiln.lock.json");
     const ws = await loadWorkspace(workspacePath);
     const id = args.name ?? loadedTarget.manifest.name;
     if (ws.projects.some((p) => p.id === id)) {
@@ -14686,19 +15736,19 @@ async function runWorkspace(args) {
       ...args.account ? { account: args.account } : {}
     };
     await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-    log(`  registered "${id}" in ${path42.relative(process.cwd(), workspacePath)}`);
+    log(`  registered "${id}" in ${path43.relative(process.cwd(), workspacePath)}`);
     log(`    manifest: ${project.manifest}`);
     log(`    lock:     ${project.lock}`);
-    if (!existsSync30(lockPath)) {
+    if (!existsSync31(lockPath)) {
       log(
-        `  warning: no lockfile there yet \u2014 this project contributes no claims until one is generated`
+        `  warning: no lockfile there yet; this project contributes no claims until one is generated`
       );
     }
     return;
   }
   if (args.subcommand === "remove") {
     const ws = await loadWorkspace(workspacePath);
-    const resolvedTarget = path42.resolve(args.target);
+    const resolvedTarget = path43.resolve(args.target);
     const match = ws.projects.find(
       (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
     );
@@ -14709,11 +15759,11 @@ async function runWorkspace(args) {
       version: 1,
       projects: ws.projects.filter((p) => p !== match)
     });
-    log(`  removed "${match.id}" from ${path42.relative(process.cwd(), workspacePath)}`);
+    log(`  removed "${match.id}" from ${path43.relative(process.cwd(), workspacePath)}`);
     return;
   }
   if (args.subcommand === "list") {
-    if (!existsSync30(workspacePath)) {
+    if (!existsSync31(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const ws = await loadWorkspace(workspacePath);
@@ -14721,9 +15771,9 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ version: 1, workspace: workspacePath, projects: ws.projects, diagnostics }, null, 2));
     } else if (!ws.projects.length) {
-      log(`  no projects registered in ${path42.relative(process.cwd(), workspacePath)}`);
+      log(`  no projects registered in ${path43.relative(process.cwd(), workspacePath)}`);
     } else {
-      log(`  ${ws.projects.length} project(s) in ${path42.relative(process.cwd(), workspacePath)}:`);
+      log(`  ${ws.projects.length} project(s) in ${path43.relative(process.cwd(), workspacePath)}:`);
       for (const p of ws.projects) {
         log(`    ${p.id.padEnd(24)} ${p.manifest.padEnd(40)} (${p.provider}${p.account ? `, ${p.account}` : ""})`);
       }
@@ -14733,7 +15783,7 @@ async function runWorkspace(args) {
     return;
   }
   if (args.subcommand === "status") {
-    if (!existsSync30(workspacePath)) {
+    if (!existsSync31(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const ws = await loadWorkspace(workspacePath);
@@ -14741,11 +15791,11 @@ async function runWorkspace(args) {
     if (args.json) {
       log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
     } else {
-      log(`  workspace: ${path42.relative(process.cwd(), workspacePath)}`);
+      log(`  workspace: ${path43.relative(process.cwd(), workspacePath)}`);
       for (const p of report.projects) {
         if (p.error) {
           log(`
-  ${p.id} \u2014 ERROR: ${p.error}`);
+  ${p.id}: ERROR: ${p.error}`);
           continue;
         }
         log(
@@ -14795,8 +15845,8 @@ async function runHelp() {
 async function runVersion() {
   for (const up of ["../package.json", "../../package.json"]) {
     const url = new URL(up, import.meta.url);
-    if (!existsSync31(url)) continue;
-    const pkg = JSON.parse(await readFile27(url, "utf8"));
+    if (!existsSync32(url)) continue;
+    const pkg = JSON.parse(await readFile28(url, "utf8"));
     if (pkg.name === "pixelkiln") {
       log(`${pkg.name} ${pkg.version}`);
       return;