pixelkiln 0.54.0 → 0.55.0

package/dist/cli.js

@@ -683,6 +683,23 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
         concept: spec.character.concept?.sha256,
         styleAnchor: spec.character.styleAnchor ? { of: spec.character.styleAnchor.assetId, sha256: spec.character.styleAnchor.sha256 } : void 0
       } : void 0,
+      // An objectPro family: same shape as character above, minus the
+      // fields it has none of (mode/template/proportions/isometric/concept/
+      // styleAnchor) — see ResolvedObjectPro.
+      objectPro: spec.objectPro ? {
+        kind: spec.objectPro.kind,
+        directions: spec.objectPro.directions,
+        parent: spec.objectPro.parentAssetId,
+        parentSha256: spec.objectPro.parentSha256 ?? null,
+        state: spec.objectPro.state,
+        animation: spec.objectPro.animation ? {
+          ...spec.objectPro.animation,
+          startFrame: spec.objectPro.animation.startFrame?.sha256,
+          endFrame: spec.objectPro.animation.endFrame?.sha256
+        } : void 0,
+        styleTraits: spec.objectPro.styleTraits,
+        reference: spec.objectPro.reference?.sha256
+      } : void 0,
       // A mirror's bytes come from its source's recorded outputs; the plan
       // compares those directly, so only the choice of source is identity.
       mirror: spec.mirror ? { of: spec.mirror.sourceAssetId } : void 0,
@@ -709,7 +726,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", "character", "terrain", "imagePro", "isometricTile"]);
+var GeneratorSchema = z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro", "isometricTile", "objectPro"]);
 var GridConfidenceSchema = z.enum(["low", "medium", "high"]);
 var RevisionModeSchema = z.enum(["image-to-image", "inpaint", "outpaint"]);
 function tileVariationCount(descriptions) {
@@ -1089,6 +1106,14 @@ var StyleObjectSchema = z.object({
    * (~50%, the API default).
    */
   isometricTileShape: z.enum(["thin tile", "thick tile", "block"]).optional(),
+  /**
+   * `objectPro` generator only. Rotations captured for a base: 1 (the API
+   * still draws and stores a single facing) or the full 8. The API default
+   * is 8. Unlike `character`, `objectPro` has no skeleton/template modes
+   * and so no `mode`/`template` fields of its own — `/create-object-pro-flash`
+   * is the only base-creation path.
+   */
+  objectDirections: z.union([z.literal(1), z.literal(8)]).optional(),
   /**
    * `pixflux` only. Whether to strip the generated background.
    *
@@ -1293,25 +1318,41 @@ var AssetSchema = z.object({
   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.
+   * `adopt` can map it without matching bytes: an object id (an
+   * `objectPro` base and state included, since they share PixelLab's
+   * `/objects` identity space), a character id, or `<id>#<animation group
+   * id>` for a character or `objectPro` 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. */
+  /**
+   * `character` or `objectPro` styles: this asset is a pose or edit of
+   * another asset in the same family. `objectPro` ignores
+   * `paletteFromReference`/`canvas` — the API has no equivalent, and
+   * always inherits the parent's exact canvas.
+   */
   state: CharacterStateSchema.optional(),
-  /** `character` styles: this asset is a loop of another character asset in one direction. */
+  /**
+   * `character` or `objectPro` styles: this asset is a loop of another
+   * asset in the same family, in one direction. `objectPro` has no
+   * skeleton/template concept, so `template`/`subject`/`outline`/
+   * `shading`/`detail` are rejected on an `objectPro` animation rather
+   * than silently ignored — describe the motion in the asset's own
+   * `prompt` instead.
+   */
   animation: CharacterAnimationSchema.optional(),
   /** `character` styles, `standard` humanoid bases: this character's proportions, over the style's. */
   proportions: CharacterProportionsSchema.optional(),
   /**
-   * `character` styles, bases only: the character's own sprite, which
-   * PixelLab rotates into the other directions instead of drawing from
-   * the prompt. A manifest-relative PNG or JPEG of the south-facing
-   * sprite, or an object keyed by direction (`{ "south": ..., "east":
-   * ... }`); quadrupeds in `standard` mode need south and east, and only
-   * `standard` takes more than south. `standard` wants each image at the
-   * style's size; v3 accepts up to 256px, pro up to 168px. The prompt
+   * `character` or `objectPro` styles, bases only: the subject's own
+   * sprite, which PixelLab rotates into the other directions instead of
+   * drawing from the prompt. A manifest-relative PNG or JPEG of the
+   * south-facing sprite, or an object keyed by direction (`{ "south":
+   * ..., "east": ... }`); quadrupeds in `standard` character mode need
+   * south and east, and only `standard` takes more than south. `objectPro`
+   * only ever reads the south image, since `/create-object-pro-flash`
+   * rotates from one frame. `standard` wants each image at the style's
+   * size; v3 accepts up to 256px, pro up to 168px. The prompt
    * still guides the result.
    */
   reference: z.union([z.string().min(1), z.record(CharacterDirectionSchema, z.string().min(1))]).optional(),
@@ -3797,6 +3838,7 @@ async function inspectRevisionReadiness(spec, lock) {
   if (spec.mirror) return inspectMirror(spec, lock, /* @__PURE__ */ new Set());
   if (spec.character?.parentSpec) return inspectCharacterParent(spec, lock, /* @__PURE__ */ new Set());
   if (spec.character?.styleAnchor) return inspectStyleAnchor(spec, lock, /* @__PURE__ */ new Set());
+  if (spec.objectPro?.parentSpec) return inspectObjectProParent(spec, lock, /* @__PURE__ */ new Set());
   if (!spec.revision) return null;
   return inspectRevision(spec, lock, /* @__PURE__ */ new Set());
 }
@@ -3838,6 +3880,24 @@ async function inspectCharacterParent(spec, lock, seen) {
   }
   return { ready: true, reason: `${label} is current` };
 }
+async function inspectObjectProParent(spec, lock, seen) {
+  const object = spec.objectPro;
+  const parentSpec = object.parentSpec;
+  const label = `${object.kind} parent ${spec.styleId}/${object.parentAssetId}`;
+  const dependency = await inspectParent(parentSpec, lock, seen);
+  if (!dependency.ready) return { ready: false, reason: `${label} is not ready: ${dependency.reason}` };
+  if (!object.parentSha256 || !object.parentFile || !existsSync4(object.parentFile)) {
+    return { ready: false, reason: `${label} has no generated south-facing file yet` };
+  }
+  if (await sha256File(object.parentFile) !== object.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 object 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" };
@@ -3889,6 +3949,10 @@ async function inspectParent(spec, lock, seen) {
     const inputs = await inspectStyleAnchor(spec, lock, nextSeen);
     if (!inputs.ready) return inputs;
   }
+  if (spec.objectPro?.parentSpec) {
+    const inputs = await inspectObjectProParent(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" } : {
@@ -3933,7 +3997,8 @@ function dependencies(spec) {
     spec.mirror?.sourceSpec,
     spec.revision?.sourceSpec,
     spec.character?.parentSpec,
-    spec.character?.styleAnchor?.spec
+    spec.character?.styleAnchor?.spec,
+    spec.objectPro?.parentSpec
   ].filter((parent) => Boolean(parent));
 }
 function resumeCommandForStatus(status) {
@@ -5281,9 +5346,23 @@ var RevisionJobSubmitSchema = z2.object({
   background_job_id: z2.string().min(1),
   status: z2.string().default("processing")
 }).passthrough();
+var ObjectAnimationGroupSchema = z2.object({
+  animation_group_id: z2.string().min(1),
+  display_name: z2.string().nullable().default(null),
+  description: z2.string().default(""),
+  frame_count: z2.number().int().default(0),
+  directions: z2.array(
+    z2.object({
+      direction: z2.string(),
+      storage_urls: z2.record(z2.unknown()).default({}),
+      created_at: z2.string()
+    }).passthrough()
+  ).default([])
+}).passthrough();
 var PixelLabObjectSchema = z2.object({
   id: z2.string().min(1),
   name: z2.string().nullable().default(null),
+  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().default(0),
@@ -5295,7 +5374,9 @@ var PixelLabObjectSchema = z2.object({
   tags: z2.array(z2.string()).default([]),
   status: z2.string().nullable().default(null),
   progress_percent: z2.number().nullable().optional(),
-  eta_seconds: z2.number().nullable().optional()
+  eta_seconds: z2.number().nullable().optional(),
+  group_id: z2.string().nullable().optional(),
+  animations: z2.array(ObjectAnimationGroupSchema).default([])
 }).passthrough();
 var MapObjectSchema = z2.object({
   object_id: z2.string().min(1),
@@ -5320,6 +5401,28 @@ var AnimateSubmitSchema = z2.object({
   status: z2.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
+var ObjectProSubmitSchema = z2.object({
+  object_id: z2.string().min(1),
+  background_job_id: z2.string().min(1),
+  status: z2.string().default("processing"),
+  usage: UsageSchema
+}).passthrough();
+var DirectionSubmissionSchema = z2.object({
+  direction: z2.string(),
+  status: z2.string(),
+  background_job_id: z2.string().nullable().default(null),
+  animation_id: z2.string().nullable().default(null)
+}).passthrough();
+var AnimateObjectSubmitSchema = z2.object({
+  animation_group_id: z2.string().min(1),
+  object_id: z2.string().min(1),
+  mode: z2.string(),
+  frame_count: z2.number().int(),
+  display_name: z2.string().nullable().default(null),
+  description: z2.string().default(""),
+  submissions: z2.array(DirectionSubmissionSchema),
+  usage: UsageSchema
+}).passthrough();
 var CharacterAnimationDirectionSchema = z2.object({
   direction: z2.string(),
   frame_count: z2.number().int().min(0),
@@ -5622,6 +5725,81 @@ var PixelLabClient = class {
       "get object"
     );
   }
+  /**
+   * A standalone object with no skeleton, one call draws the south sprite
+   * (or takes the author's) and rotates it with v3 — the character
+   * pro-flash pattern, minus `template_id` (objects have no skeleton) and
+   * with a real `n_directions` choice (1 or 8, character pro-flash is
+   * always 8). Async only: `/create-object-pro-flash` has no sync response.
+   */
+  async createObjectProFlash(args) {
+    const encode = (image) => ({ type: "base64", base64: image.base64, format: image.format });
+    const traits = args.styleTraits;
+    const body = {
+      description: args.description,
+      n_directions: args.directions,
+      ...args.reference ? { first_frame: encode(args.reference) } : { image_size: { width: args.size, height: args.size } },
+      ...args.view ? { view: args.view } : {},
+      ...args.seed != null ? { seed: args.seed } : {},
+      ...args.styleReference && args.styleReferenceSize ? {
+        style_image: { image: encode(args.styleReference), size: args.styleReferenceSize },
+        ...traits ? {
+          style_options: {
+            ...traits.palette !== void 0 ? { color_palette: traits.palette } : {},
+            ...traits.outline !== void 0 ? { outline: traits.outline } : {},
+            ...traits.detail !== void 0 ? { detail: traits.detail } : {},
+            ...traits.shading !== void 0 ? { shading: traits.shading } : {}
+          }
+        } : {}
+      } : {}
+    };
+    return validateResponse(
+      ObjectProSubmitSchema,
+      await this.request("/create-object-pro-flash", { method: "POST", body: JSON.stringify(body) }),
+      "create-object-pro-flash"
+    );
+  }
+  /** A text edit of an existing object, applied to its whole rotation set and stored as a sibling. Always inherits the parent's exact canvas — no size override exists on this endpoint. */
+  async createObjectProState(args) {
+    const raw = await this.request(`/objects/${encodeURIComponent(args.objectId)}/states`, {
+      method: "POST",
+      body: JSON.stringify({
+        edit_description: args.editDescription,
+        ...args.stateName ? { state_name: args.stateName } : {},
+        ...args.seed != null ? { seed: args.seed } : {}
+      })
+    });
+    return validateResponse(ObjectProSubmitSchema, raw, "create object state");
+  }
+  /**
+   * One direction of one object's animation. Unlike character animation,
+   * this endpoint's own `replace_existing` flag regenerates an
+   * already-animated direction directly (character has no such flag and
+   * pixelkiln instead deletes the prior take itself before resubmitting;
+   * see `submitCharacter`). A 1-direction object must not receive
+   * `directions` at all -- the API 400s if it does.
+   */
+  async animateObject(args) {
+    const encode = (image) => ({ type: "base64", base64: image.base64, format: image.format });
+    const body = {
+      mode: args.mode,
+      ...args.directions === 8 ? { directions: [args.direction] } : {},
+      ...args.animationDescription ? { animation_description: args.animationDescription } : {},
+      ...args.animationGroupId ? { animation_group_id: args.animationGroupId } : {},
+      ...args.displayName ? { display_name: args.displayName } : {},
+      ...args.frameCount != null ? { frame_count: args.frameCount } : {},
+      ...args.keepFirstFrame === false ? { keep_first_frame: false } : {},
+      ...args.startFrame ? { custom_start_frame: encode(args.startFrame) } : {},
+      ...args.endFrame ? { end_frame: encode(args.endFrame) } : {},
+      ...args.enhancePrompt ? { enhance_prompt: true } : {},
+      ...args.replaceExisting ? { replace_existing: true } : {}
+    };
+    const raw = await this.request(`/objects/${encodeURIComponent(args.objectId)}/animations`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    return validateResponse(AnimateObjectSubmitSchema, raw, "animate object");
+  }
   async getMapObject(objectId) {
     return validateResponse(
       MapObjectSchema,
@@ -6021,6 +6199,29 @@ function proFlashCharacterCost(width, height, fromReference) {
 function characterAnimationName(spec) {
   return `pixelkiln:${spec.styleId}/${spec.assetId}`;
 }
+function objectAnimationName(spec) {
+  return `pixelkiln:${spec.styleId}/${spec.assetId}`;
+}
+function proFlashObjectCost(width, height, directions, fromReference) {
+  const side = Math.max(32, Math.ceil(Math.max(width, height) / 4) * 4);
+  const rotations = Math.max(1, Math.ceil(side * side * directions / 65536));
+  if (fromReference) return rotations;
+  const image = side <= 96 ? 5 : side <= 208 ? 6 : 9;
+  return image + rotations;
+}
+function objectProCost(spec) {
+  const object = spec.objectPro;
+  if (!object) return generationCost(spec.width, spec.height, "1dir");
+  const px = spec.width * spec.height;
+  if (object.kind === "animation") {
+    const animation = object.animation;
+    if (animation.mode === "pro") return generationCost(spec.width, spec.height, "1dir");
+    return Math.max(1, Math.ceil(px * animation.frames / 65536));
+  }
+  if (object.kind === "state") return generationCost(spec.width, spec.height, "1dir");
+  const south = object.reference;
+  return south ? proFlashObjectCost(south.width, south.height, object.directions, true) : proFlashObjectCost(spec.width, spec.height, object.directions, false);
+}
 var CHARACTER_TEMPLATES = ["mannequin", "bear", "cat", "dog", "horse", "lion"];
 var PRO_FLASH_TEMPLATES = [...CHARACTER_TEMPLATES, "custom"];
 function encodeAnimationJob(job) {
@@ -6037,6 +6238,20 @@ function decodeAnimationJob(jobId) {
   }
   return null;
 }
+function encodeObjectAnimationJob(job) {
+  return `object-animation:${Buffer.from(JSON.stringify(job)).toString("base64url")}`;
+}
+function decodeObjectAnimationJob(jobId) {
+  if (!jobId.startsWith("object-animation:")) return null;
+  try {
+    const value = JSON.parse(Buffer.from(jobId.slice("object-animation:".length), "base64url").toString("utf8"));
+    if (typeof value?.objectId === "string" && typeof value.name === "string" && typeof value.direction === "string") {
+      return { objectId: value.objectId, name: value.name, direction: value.direction, jobId: typeof value.jobId === "string" ? value.jobId : null };
+    }
+  } catch {
+  }
+  return null;
+}
 var PixelLabProvider = class _PixelLabProvider {
   constructor(client2) {
     this.client = client2;
@@ -6055,7 +6270,7 @@ var PixelLabProvider = class _PixelLabProvider {
     return new _PixelLabProvider(new PixelLabClient("download-only"));
   }
   supports(generator) {
-    return generator === "1dir" || generator === "map" || generator === "pixflux" || generator === "tiles" || generator === "terrain" || generator === "imagePro" || generator === "character" || generator === "isometricTile";
+    return generator === "1dir" || generator === "map" || generator === "pixflux" || generator === "tiles" || generator === "terrain" || generator === "imagePro" || generator === "character" || generator === "isometricTile" || generator === "objectPro";
   }
   /**
    * `inpaint` (`/inpaint-v3`, a mask) and `image-to-image` (`/edit-images-v2`,
@@ -6097,6 +6312,9 @@ var PixelLabProvider = class _PixelLabProvider {
     if (spec.generator === "character") {
       return { unit: "generations", amount: characterCost(spec), candidates: 1 };
     }
+    if (spec.generator === "objectPro") {
+      return { unit: "generations", amount: objectProCost(spec), candidates: 1 };
+    }
     return {
       unit: "generations",
       amount: generationCost(spec.width, spec.height, spec.generator),
@@ -6205,6 +6423,7 @@ var PixelLabProvider = class _PixelLabProvider {
       }
     }
     if (spec.generator === "character") this.validateCharacter(spec, styleImages);
+    if (spec.generator === "objectPro") this.validateObjectPro(spec, styleImages);
     if ((spec.generator === "map" || spec.generator === "pixflux") && styleImages.length) {
       throw new Error(`PixelLab ${spec.generator} does not support style images`);
     }
@@ -6365,6 +6584,63 @@ var PixelLabProvider = class _PixelLabProvider {
       }
     }
   }
+  validateObjectPro(spec, styleImages = []) {
+    const object = spec.objectPro;
+    if (!object) throw new Error(`${spec.styleId}/${spec.assetId} has no objectPro shape`);
+    const label = `${spec.styleId}/${spec.assetId}`;
+    if (object.kind === "base" && object.reference && styleImages.length) {
+      throw new Error(`${label}: a base rotating its own reference sprite takes no style image`);
+    }
+    if (object.reference && (object.reference.width > 256 || object.reference.height > 256)) {
+      throw new Error(`${label}: reference is ${object.reference.width}x${object.reference.height}; PixelLab objectPro takes up to 256px`);
+    }
+    if (styleImages.length) {
+      if (styleImages.length > 1) throw new Error(`PixelLab objectPro takes one style image`);
+      const image = styleImages[0];
+      if (image.width > 256 || image.height > 256) {
+        throw new Error(`PixelLab objectPro style image is ${image.width}x${image.height}; the limit is 256px`);
+      }
+      if (image.width > spec.width || image.height > spec.height) {
+        throw new Error(
+          `PixelLab objectPro style image is ${image.width}x${image.height} but the object is ${spec.width}x${spec.height}; crop the image to its subject or raise the style's size`
+        );
+      }
+    }
+    if (object.kind === "base" && (spec.width < 16 || spec.height < 16 || spec.width > 256 || spec.height > 256)) {
+      throw new Error(`PixelLab objectPro bases must be between 16 and 256 pixels`);
+    }
+    if (object.kind === "base" && (spec.width % 4 || spec.height % 4)) {
+      throw new Error(`PixelLab objectPro bases are sized in multiples of 4 pixels; ${spec.width}x${spec.height} is not`);
+    }
+    if (object.kind !== "base" && !object.parentAssetId) {
+      throw new Error(`${spec.styleId}/${spec.assetId} is a ${object.kind} with no parent`);
+    }
+    if (object.animation) {
+      const allowed = object.directions === 1 ? ["south"] : CHARACTER_DIRECTIONS_8;
+      if (!allowed.includes(object.animation.direction)) {
+        throw new Error(
+          `${label} animates "${object.animation.direction}", but its object has ${object.directions} direction${object.directions === 1 ? "" : "s"}: ${allowed.join(", ")}`
+        );
+      }
+      if (!spec.prompt.trim()) {
+        throw new Error(`${label} needs a prompt describing the motion`);
+      }
+      const { startFrame, endFrame } = object.animation;
+      for (const [name, image] of [["start frame", startFrame], ["end frame", endFrame]]) {
+        if (image && (image.width > 256 || image.height > 256)) {
+          throw new Error(`${label}: ${name} is ${image.width}x${image.height}; PixelLab v3 takes up to 256px`);
+        }
+      }
+      if (endFrame) {
+        const start = startFrame ?? (object.parentFile && existsSync7(object.parentFile) ? imageMetadata(readFileSync2(object.parentFile)) : null);
+        if (start && (start.width !== endFrame.width || start.height !== endFrame.height)) {
+          throw new Error(
+            `${label}: end frame is ${endFrame.width}x${endFrame.height} but the ${startFrame ? "start frame" : "object's rotation"} is ${start.width}x${start.height}; PixelLab interpolates between frames of one size`
+          );
+        }
+      }
+    }
+  }
   /**
    * 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
@@ -6458,6 +6734,78 @@ var PixelLabProvider = class _PixelLabProvider {
       metadata: { character: { kind: "animation", characterId: parentId, animationName: name, direction: animation.direction, mode: animation.mode, backgroundJobIds: res.background_job_ids } }
     };
   }
+  /**
+   * Same shape as `submitCharacter`, minus the mode branching (objectPro has
+   * exactly one base-creation path) and minus the client-side "find and
+   * delete the prior take" dance for animation: `/objects/{id}/animations`
+   * has its own `replace_existing` flag, so this always passes it rather
+   * than fetching the object first to check.
+   */
+  async submitObjectPro(spec, styleImages, context) {
+    const object = spec.objectPro;
+    if (object.kind === "base") {
+      const styleImage = styleImages[0];
+      const res2 = await this.client.createObjectProFlash({
+        description: spec.prompt,
+        directions: object.directions,
+        size: spec.width,
+        view: spec.view,
+        seed: spec.seed,
+        reference: object.reference ? readPose(spec, "reference sprite", object.reference) : void 0,
+        styleReference: styleImage ? { base64: styleImage.base64, format: styleImage.format } : void 0,
+        styleReferenceSize: styleImage ? { width: styleImage.width, height: styleImage.height } : void 0,
+        styleTraits: object.styleTraits
+      });
+      return { jobId: res2.object_id, metadata: { objectPro: { kind: "base", objectId: res2.object_id, directions: object.directions, backgroundJobId: res2.background_job_id } } };
+    }
+    const parentId = context?.parentObjectId;
+    if (!parentId) {
+      throw new Error(
+        `${spec.styleId}/${spec.assetId} is a ${object.kind} of ${object.parentAssetId}, which has no PixelLab object id in the lockfile yet; generate the parent first`
+      );
+    }
+    if (object.kind === "state") {
+      const res2 = await this.client.createObjectProState({
+        objectId: parentId,
+        editDescription: spec.prompt,
+        stateName: spec.assetId.slice(0, 50),
+        seed: spec.seed
+      });
+      return { jobId: res2.object_id, metadata: { objectPro: { kind: "state", objectId: res2.object_id, parentObjectId: parentId, directions: object.directions, backgroundJobId: res2.background_job_id } } };
+    }
+    const animation = object.animation;
+    const name = objectAnimationName(spec);
+    const res = await this.client.animateObject({
+      objectId: parentId,
+      directions: object.directions,
+      direction: animation.direction,
+      animationDescription: spec.prompt.trim() || void 0,
+      displayName: name,
+      mode: animation.mode === "pro" ? "pro" : "v3",
+      frameCount: animation.frames,
+      keepFirstFrame: animation.keepFirstFrame,
+      startFrame: animation.startFrame ? readPose(spec, "start frame", animation.startFrame) : void 0,
+      endFrame: animation.endFrame ? readPose(spec, "end frame", animation.endFrame) : void 0,
+      enhancePrompt: animation.enhancePrompt,
+      replaceExisting: true
+    });
+    const submission = res.submissions.find((s) => s.direction === animation.direction) ?? res.submissions[0];
+    const job = { objectId: parentId, name, direction: animation.direction, jobId: submission?.background_job_id ?? null };
+    return {
+      jobId: encodeObjectAnimationJob(job),
+      metadata: {
+        objectPro: {
+          kind: "animation",
+          objectId: parentId,
+          animationName: name,
+          direction: animation.direction,
+          mode: animation.mode,
+          animationGroupId: res.animation_group_id,
+          animationId: submission?.animation_id ?? null
+        }
+      }
+    };
+  }
   async pollCharacter(jobId, context) {
     const animation = decodeAnimationJob(jobId);
     if (animation) return this.pollCharacterAnimation(animation, context);
@@ -6541,10 +6889,93 @@ var PixelLabProvider = class _PixelLabProvider {
     if (found) return review(found.frames, found.animationId, found.groupId, null);
     return cleanedUp ? { status: "failed", error: `animation job is gone upstream and no "${job.name}" ${job.direction} animation exists on the character` } : { status: "processing" };
   }
+  async pollObjectPro(jobId, context) {
+    const animation = decodeObjectAnimationJob(jobId);
+    if (animation) return this.pollObjectProAnimation(animation, context);
+    const object = await this.client.getObject(jobId);
+    if (object.status === "failed") return { status: "failed", error: "object generation failed upstream" };
+    if (object.status !== "completed" || !object.rotation_urls) return { status: "processing" };
+    const sources = objectRotationSources(object);
+    if (!sources.length) return { status: "failed", error: "object completed with no rotation images" };
+    const backgroundJobId = context?.metadata?.objectPro?.backgroundJobId;
+    return {
+      status: "ready",
+      objectId: object.id,
+      sourceUrl: sources[0].url,
+      sources,
+      metadata: {
+        objectPro: {
+          objectId: object.id,
+          groupId: object.group_id ?? null,
+          name: object.name,
+          stateName: object.state_name ?? null,
+          directions: object.directions,
+          size: object.size
+        }
+      },
+      billed: await this.billedForJob(backgroundJobId)
+    };
+  }
+  /**
+   * Same resilience shape as `pollCharacterAnimation`: the background job is
+   * the authoritative record while it lasts, the object's own `animations`
+   * list (matched by the `pixelkiln:` display name this asset submitted, or
+   * a recorded animation id) is the fallback once PixelLab cleans the job
+   * up. Never declares failure from absence alone -- a `rate_limited`
+   * `DirectionSubmission` has no background job id at all, so this keeps
+   * reporting "processing" rather than guessing a job that never existed
+   * has failed.
+   */
+  async pollObjectProAnimation(job, context) {
+    const fps = context?.spec?.objectPro?.animation?.fps ?? 8;
+    const review = (frames, animationId, groupId, billed) => ({
+      status: "review-set",
+      objectId: `${job.objectId}#${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 },
+        objectPro: {
+          kind: "animation",
+          objectId: job.objectId,
+          animationId,
+          animationGroupId: groupId,
+          animationName: job.name,
+          direction: job.direction
+        }
+      },
+      billed
+    });
+    if (job.jobId) {
+      const status = await this.client.getBackgroundJob(job.jobId).catch((err) => {
+        if (err instanceof PixelLabError && err.status === 404) return null;
+        throw err;
+      });
+      if (status) {
+        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 object2 = await this.client.getObject(job.objectId);
+          const group = findObjectAnimation(object2, job.name, job.direction, animationId);
+          return review(frames, animationId, group?.groupId ?? null, billedFromUsage(status.usage));
+        }
+      }
+    }
+    const recorded = context?.metadata?.objectPro?.animationId ?? null;
+    const object = await this.client.getObject(job.objectId);
+    const found = findObjectAnimation(object, job.name, job.direction, recorded);
+    if (found) return review(found.frames, found.animationId, found.groupId, null);
+    return { status: "processing" };
+  }
   async submit(spec, styleImages, context) {
     this.validate(spec, styleImages);
     if (spec.revision) return this.submitRevision(spec);
     if (spec.generator === "character") return this.submitCharacter(spec, styleImages, context);
+    if (spec.generator === "objectPro") return this.submitObjectPro(spec, styleImages, context);
     if (spec.generator === "pixflux") {
       const swatch = spec.palette.length ? paletteSwatch(spec.palette).toString("base64") : void 0;
       const { png } = await this.client.createImagePixflux({
@@ -6738,6 +7169,7 @@ var PixelLabProvider = class _PixelLabProvider {
     if (generator === "isometricTile") return this.pollIsometricTile(jobId, context);
     if (generator === "imagePro") return this.pollImagePro(jobId);
     if (generator === "character") return this.pollCharacter(jobId, context);
+    if (generator === "objectPro") return this.pollObjectPro(jobId, context);
     const backgroundJobId = context?.metadata?.backgroundJobId;
     const obj = await this.client.getObject(jobId);
     if (obj.status === "review") {
@@ -7155,6 +7587,28 @@ function findAnimation(character, name, direction, animationId) {
   }
   return null;
 }
+function objectRotationSources(object) {
+  const order = object.directions === 1 ? ["south"] : CHARACTER_DIRECTIONS_8;
+  const sources = [];
+  for (const direction of order) {
+    const url = object.rotation_urls?.[direction];
+    if (url) sources.push({ url, role: direction });
+  }
+  return sources;
+}
+function findObjectAnimation(object, name, direction, animationId) {
+  for (const group of object.animations) {
+    const match = group.directions.find((d) => d.direction === direction);
+    const frames = match ? match.storage_urls.frames : void 0;
+    if (!match || !Array.isArray(frames) || !frames.length || !frames.every((f) => typeof f === "string")) continue;
+    const byName = group.display_name === name;
+    const byId = animationId !== null && frames.some((url) => url.includes(`/animations/${animationId}/`));
+    if (!byName && !byId) continue;
+    const fromUrl = /\/animations\/([^/]+)\//.exec(frames[0])?.[1] ?? null;
+    return { frames, groupId: group.animation_group_id, animationId: animationId ?? fromUrl };
+  }
+  return null;
+}
 
 // src/providers/retrodiffusion.ts
 var DEFAULT_BASE_URL2 = "https://api.retrodiffusion.ai/v1";
@@ -8334,14 +8788,18 @@ async function resolveSpecs(loaded, filter) {
         size = asset.size ?? style.size ?? 32;
         width = size;
         height = size;
+      } else if (generator === "objectPro") {
+        size = asset.size ?? style.size ?? 64;
+        width = size;
+        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") {
+      if ((asset.state || asset.animation) && generator !== "character" && generator !== "objectPro") {
         throw new Error(
-          `assets.${assetId}: ${asset.state ? "state" : "animation"} needs a character style; "${styleId}" generates ${generator}`
+          `assets.${assetId}: ${asset.state ? "state" : "animation"} needs a character or objectPro style; "${styleId}" generates ${generator}`
         );
       }
       const characterKind = asset.animation ? "animation" : asset.state ? "state" : "base";
@@ -8362,7 +8820,7 @@ async function resolveSpecs(loaded, filter) {
         terrainUpperDescription = wrap(parsed.upper);
         terrainTransitionDescription = parsed.transition ? wrap(parsed.transition) : void 0;
         prompt = subject.trim();
-      } else if (generator === "character" && characterKind !== "base") {
+      } else if ((generator === "character" || generator === "objectPro") && characterKind !== "base") {
         prompt = subject.trim();
       } else {
         prompt = [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
@@ -8430,6 +8888,7 @@ async function resolveSpecs(loaded, filter) {
         isometricTileSize: generator === "isometricTile" ? style.isometricTileSize : void 0,
         isometricTileShape: generator === "isometricTile" ? style.isometricTileShape : void 0,
         ...generator === "character" ? { character: await resolveCharacterShape(asset, style, characterKind, { root, load: loadStyleImage }) } : {},
+        ...generator === "objectPro" ? { objectPro: await resolveObjectProShape(assetId, asset, style, characterKind, { root, load: loadStyleImage }) } : {},
         cost: generator === "tiles" ? tilesCost(tileSize, tileVariations) : generator === "terrain" ? tilesCost(size, terrainTiles) : generator === "isometricTile" ? isometricTileCost() : generationCost(width, height, generator),
         costUnit: "generations",
         candidates: generator === "tiles" ? tileVariations : generator === "terrain" ? terrainTiles : generator === "1dir" || generator === "imagePro" ? candidateCount(size) : 1
@@ -8495,6 +8954,18 @@ async function resolveSpecs(loaded, filter) {
         } else if (sourceSpec.character) {
           resolved.character = { ...sourceSpec.character };
         }
+        if (sourceSpec.objectPro?.kind === "animation") {
+          const facing = sourceSpec.objectPro.animation.direction;
+          const mirrored = MIRRORED_DIRECTION[facing];
+          if (mirrored === facing) {
+            throw new Error(
+              `assets.${assetId}: mirroring ${asset.mirror} gives another ${facing}-facing loop; mirror a loop facing east, west, or a diagonal`
+            );
+          }
+          resolved.objectPro = { ...sourceSpec.objectPro, animation: { ...sourceSpec.objectPro.animation, direction: mirrored } };
+        } else if (sourceSpec.objectPro) {
+          resolved.objectPro = { ...sourceSpec.objectPro };
+        }
         resolved.mirror = { sourceAssetId: asset.mirror, sourceSpec };
         resolved.generator = sourceSpec.generator;
         resolved.width = sourceSpec.width;
@@ -8536,6 +9007,23 @@ async function resolveSpecs(loaded, filter) {
           directions: resolved.character.kind === "base" ? resolved.character.directions : parentSpec.character?.directions ?? resolved.character.directions
         };
       }
+      if (resolved.objectPro && characterParent) {
+        const parentSpec = await finalize(characterParent);
+        if (!parentSpec.objectPro) {
+          throw new Error(`assets.${assetId}: ${characterParent} is not an objectPro asset`);
+        }
+        const parentDirections = parentSpec.objectPro.directions;
+        const parentFile = memberPath(parentSpec.outFile, "south", 0, parentDirections, MediaType.PNG);
+        resolved.objectPro = {
+          ...resolved.objectPro,
+          parentAssetId: characterParent,
+          parentSpec,
+          parentFile,
+          parentSha256: existsSync8(parentFile) ? await sha256File(parentFile) : null,
+          // A state and its animations keep the base's own rotation count.
+          directions: resolved.objectPro.kind === "base" ? resolved.objectPro.directions : parentSpec.objectPro.directions
+        };
+      }
       if (asset.revision) {
         if (!activeProvider.supportsRevision?.(asset.revision.mode)) {
           throw new Error(
@@ -8718,6 +9206,60 @@ async function resolveCharacterShape(asset, style, kind, files) {
   }
   return shape;
 }
+async function resolveObjectProShape(assetId, asset, style, kind, files) {
+  const directions = style.objectDirections ?? 8;
+  const shape = {
+    kind,
+    directions,
+    ...style.styleTraits ? { styleTraits: style.styleTraits } : {}
+  };
+  if (asset.reference) {
+    const south = typeof asset.reference === "string" ? asset.reference : asset.reference.south;
+    if (south) {
+      const image = await files.load(south, "Reference sprite");
+      shape.reference = { path: path13.resolve(files.root, south), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+    }
+  }
+  if (asset.state) {
+    shape.state = {
+      paletteFromReference: asset.state.paletteFromReference,
+      ...asset.state.canvas ? { canvas: asset.state.canvas } : {}
+    };
+  }
+  if (asset.animation) {
+    for (const [field, value] of Object.entries({
+      template: asset.animation.template,
+      subject: asset.animation.subject,
+      outline: asset.animation.outline,
+      shading: asset.animation.shading,
+      detail: asset.animation.detail
+    })) {
+      if (value !== void 0) {
+        throw new Error(
+          `assets.${assetId}: objectPro has no skeleton/template concept, so animation.${field} does not apply; describe the motion in the asset's own prompt instead`
+        );
+      }
+    }
+    if (asset.animation.mode === "template") {
+      throw new Error(`assets.${assetId}: objectPro animations have no "template" mode; use "v3" or "pro"`);
+    }
+    const pose = async (rel, what) => {
+      const image = await files.load(rel, what);
+      return { path: path13.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+    };
+    shape.animation = {
+      mode: asset.animation.mode ?? "v3",
+      direction: asset.animation.direction,
+      frames: asset.animation.frames ?? 8,
+      fps: asset.animation.fps,
+      keepFirstFrame: asset.animation.keepFirstFrame,
+      ...asset.animation.startFrame ? { startFrame: await pose(asset.animation.startFrame, "Animation start frame") } : {},
+      ...asset.animation.endFrame ? { endFrame: await pose(asset.animation.endFrame, "Animation end frame") } : {},
+      ...asset.animation.enhancePrompt !== void 0 ? { enhancePrompt: asset.animation.enhancePrompt } : {}
+    };
+  }
+  return shape;
+}
 
 // src/pipeline/fetch.ts
 import { existsSync as existsSync9, readFileSync as readFileSync3 } from "fs";
@@ -12840,7 +13382,8 @@ 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 parentSpec = spec.character?.parentSpec ?? spec.objectPro?.parentSpec;
+      const parentEntry = parentSpec ? lock.entries[lockKey(parentSpec.styleId, parentSpec.assetId)] : void 0;
       const anchor = spec.character?.styleAnchor;
       const anchorEntry = anchor ? lock.entries[lockKey(anchor.spec.styleId, anchor.spec.assetId)] : void 0;
       const replacedMetadata = previousEntry?.providerMetadata?.[provider.id];