pixelkiln 0.53.4 → 0.55.0

package/dist/index.cjs

@@ -169,6 +169,7 @@ __export(index_exports, {
   isFrameSetEntry: () => isFrameSetEntry,
   isMemberSetEntry: () => isMemberSetEntry,
   isSensitiveSourceUrl: () => isSensitiveSourceUrl,
+  isometricTileCost: () => isometricTileCost,
   listBundledRecipes: () => listBundledRecipes,
   loadClaims: () => loadClaims,
   loadLock: () => loadLock,
@@ -303,7 +304,7 @@ var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 // src/types.ts
 var import_zod = require("zod");
 var MediaTypeSchema = import_zod.z.enum(["image/png", "image/gif"]);
-var GeneratorSchema = import_zod.z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro"]);
+var GeneratorSchema = import_zod.z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro", "isometricTile", "objectPro"]);
 var GridConfidenceSchema = import_zod.z.enum(["low", "medium", "high"]);
 var RevisionModeSchema = import_zod.z.enum(["image-to-image", "inpaint", "outpaint"]);
 function tileVariationCount(descriptions) {
@@ -337,6 +338,9 @@ function tilesCost(tileSize, variations) {
   if (px <= 2048) return 25;
   return 40;
 }
+function isometricTileCost() {
+  return 1;
+}
 function terrainTileCount(transitionSize) {
   return transitionSize === 1 ? 25 : 16;
 }
@@ -666,6 +670,28 @@ var StyleObjectSchema = import_zod.z.object({
   /** `terrain` generator only. Camera angle; the API default is `high
    *  top-down`. */
   terrainView: import_zod.z.enum(["low top-down", "high top-down"]).optional(),
+  /**
+   * `isometricTile` generator only. `/create-isometric-tile`'s own tile
+   * grid size, distinct from `size` (the generation canvas, 16-64px — the
+   * API's own guidance is that sizes above 24px "often produce better
+   * quality results"). The API default is 16.
+   */
+  isometricTileSize: import_zod.z.union([import_zod.z.literal(16), import_zod.z.literal(32)]).optional(),
+  /**
+   * `isometricTile` generator only. Vertical thickness, i.e. how much
+   * height/elevation variation the tile can represent on a map: `"thin
+   * tile"` (~15% of canvas height), `"thick tile"` (~25%), or `"block"`
+   * (~50%, the API default).
+   */
+  isometricTileShape: import_zod.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: import_zod.z.union([import_zod.z.literal(1), import_zod.z.literal(8)]).optional(),
   /**
    * `pixflux` only. Whether to strip the generated background.
    *
@@ -870,25 +896,41 @@ var AssetSchema = import_zod.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: import_zod.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: import_zod.z.union([import_zod.z.string().min(1), import_zod.z.record(CharacterDirectionSchema, import_zod.z.string().min(1))]).optional(),
@@ -1370,13 +1412,36 @@ var TilesetGetSchema = import_zod2.z.object({
   }).passthrough(),
   usage: UsageSchema
 }).passthrough();
+var IsometricTileSubmitSchema = import_zod2.z.object({
+  tile_id: import_zod2.z.string().min(1),
+  background_job_id: import_zod2.z.string().min(1),
+  status: import_zod2.z.literal("processing").default("processing")
+}).passthrough();
+var IsometricTileGetSchema = import_zod2.z.object({
+  image: import_zod2.z.object({ base64: import_zod2.z.string().min(1), format: import_zod2.z.string().default("png") }).passthrough(),
+  usage: UsageSchema
+}).passthrough();
 var RevisionJobSubmitSchema = import_zod2.z.object({
   background_job_id: import_zod2.z.string().min(1),
   status: import_zod2.z.string().default("processing")
 }).passthrough();
+var ObjectAnimationGroupSchema = import_zod2.z.object({
+  animation_group_id: import_zod2.z.string().min(1),
+  display_name: import_zod2.z.string().nullable().default(null),
+  description: import_zod2.z.string().default(""),
+  frame_count: import_zod2.z.number().int().default(0),
+  directions: import_zod2.z.array(
+    import_zod2.z.object({
+      direction: import_zod2.z.string(),
+      storage_urls: import_zod2.z.record(import_zod2.z.unknown()).default({}),
+      created_at: import_zod2.z.string()
+    }).passthrough()
+  ).default([])
+}).passthrough();
 var PixelLabObjectSchema = import_zod2.z.object({
   id: import_zod2.z.string().min(1),
   name: import_zod2.z.string().nullable().default(null),
+  state_name: import_zod2.z.string().nullable().optional(),
   prompt: import_zod2.z.string().default(""),
   size: import_zod2.z.object({ width: import_zod2.z.number().int().positive(), height: import_zod2.z.number().int().positive() }),
   directions: import_zod2.z.number().default(0),
@@ -1388,7 +1453,9 @@ var PixelLabObjectSchema = import_zod2.z.object({
   tags: import_zod2.z.array(import_zod2.z.string()).default([]),
   status: import_zod2.z.string().nullable().default(null),
   progress_percent: import_zod2.z.number().nullable().optional(),
-  eta_seconds: import_zod2.z.number().nullable().optional()
+  eta_seconds: import_zod2.z.number().nullable().optional(),
+  group_id: import_zod2.z.string().nullable().optional(),
+  animations: import_zod2.z.array(ObjectAnimationGroupSchema).default([])
 }).passthrough();
 var MapObjectSchema = import_zod2.z.object({
   object_id: import_zod2.z.string().min(1),
@@ -1413,6 +1480,28 @@ var AnimateSubmitSchema = import_zod2.z.object({
   status: import_zod2.z.string().default("processing"),
   usage: UsageSchema
 }).passthrough();
+var ObjectProSubmitSchema = import_zod2.z.object({
+  object_id: import_zod2.z.string().min(1),
+  background_job_id: import_zod2.z.string().min(1),
+  status: import_zod2.z.string().default("processing"),
+  usage: UsageSchema
+}).passthrough();
+var DirectionSubmissionSchema = import_zod2.z.object({
+  direction: import_zod2.z.string(),
+  status: import_zod2.z.string(),
+  background_job_id: import_zod2.z.string().nullable().default(null),
+  animation_id: import_zod2.z.string().nullable().default(null)
+}).passthrough();
+var AnimateObjectSubmitSchema = import_zod2.z.object({
+  animation_group_id: import_zod2.z.string().min(1),
+  object_id: import_zod2.z.string().min(1),
+  mode: import_zod2.z.string(),
+  frame_count: import_zod2.z.number().int(),
+  display_name: import_zod2.z.string().nullable().default(null),
+  description: import_zod2.z.string().default(""),
+  submissions: import_zod2.z.array(DirectionSubmissionSchema),
+  usage: UsageSchema
+}).passthrough();
 var CharacterAnimationDirectionSchema = import_zod2.z.object({
   direction: import_zod2.z.string(),
   frame_count: import_zod2.z.number().int().min(0),
@@ -1655,6 +1744,33 @@ var PixelLabClient = class {
     );
     return { tileset: res.tileset, usage: res.usage ?? null };
   }
+  /** A single standalone isometric tile — no connectable set, no candidates. */
+  async createIsometricTile(args) {
+    const body = { description: args.description };
+    if (args.imageWidth != null && args.imageHeight != null) {
+      body.image_size = { width: args.imageWidth, height: args.imageHeight };
+    }
+    if (args.tileSize != null) body.isometric_tile_size = args.tileSize;
+    if (args.tileShape) body.isometric_tile_shape = args.tileShape;
+    if (args.outline) body.outline = args.outline;
+    if (args.shading) body.shading = args.shading;
+    if (args.detail) body.detail = args.detail;
+    if (args.seed != null) body.seed = args.seed;
+    return validateResponse(
+      IsometricTileSubmitSchema,
+      await this.request("/create-isometric-tile", { method: "POST", body: JSON.stringify(body) }),
+      "create isometric tile"
+    );
+  }
+  /** Throws PixelLabError(423) while the tile is still processing. */
+  async getIsometricTile(tileId) {
+    const res = await validateResponse(
+      IsometricTileGetSchema,
+      await this.request(`/isometric-tiles/${tileId}`),
+      "get isometric tile"
+    );
+    return { image: res.image, usage: res.usage ?? null };
+  }
   /**
    * Synchronous single-image generation. Returns the PNG inline rather than a
    * job id, and is the only endpoint that honours a forced palette;
@@ -1688,6 +1804,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,
@@ -2633,6 +2824,8 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
       tileView: spec.tileView,
       tileFeature: spec.tileFeature,
       outlineMode: spec.outlineMode,
+      isometricTileSize: spec.isometricTileSize,
+      isometricTileShape: spec.isometricTileShape,
       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
@@ -2661,6 +2854,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,
@@ -2728,6 +2938,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) {
@@ -2744,6 +2977,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;
@@ -2762,7 +3009,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";
+    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`,
@@ -2798,12 +3045,15 @@ var PixelLabProvider = class _PixelLabProvider {
       const height = spec.revision.sourceHeight ?? spec.height;
       return { unit: "generations", amount: generationCost(width, height, "1dir"), candidates: 1 };
     }
-    if (spec.generator === "tiles" || spec.generator === "terrain") {
+    if (spec.generator === "tiles" || spec.generator === "terrain" || spec.generator === "isometricTile") {
       return { unit: "generations", amount: spec.cost, candidates: spec.candidates };
     }
     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),
@@ -2829,19 +3079,19 @@ var PixelLabProvider = class _PixelLabProvider {
       );
     }
     if (spec.generator === "map") {
-      requirePixelLabOption("view", spec.view, ["low top-down", "high top-down", "side"]);
-      requirePixelLabOption("outline", spec.outline, [
+      requirePixelLabOption("map", "view", spec.view, ["low top-down", "high top-down", "side"]);
+      requirePixelLabOption("map", "outline", spec.outline, [
         "single color outline",
         "selective outline",
         "lineless"
       ]);
-      requirePixelLabOption("shading", spec.shading, [
+      requirePixelLabOption("map", "shading", spec.shading, [
         "flat shading",
         "basic shading",
         "medium shading",
         "detailed shading"
       ]);
-      requirePixelLabOption("detail", spec.detail, [
+      requirePixelLabOption("map", "detail", spec.detail, [
         "low detail",
         "medium detail",
         "high detail"
@@ -2849,7 +3099,7 @@ var PixelLabProvider = class _PixelLabProvider {
     }
     if (spec.generator === "terrain") {
       if (spec.outline) {
-        requirePixelLabOption("outline", spec.outline, [
+        requirePixelLabOption("terrain", "outline", spec.outline, [
           "single color black outline",
           "single color outline",
           "selective outline",
@@ -2857,7 +3107,7 @@ var PixelLabProvider = class _PixelLabProvider {
         ]);
       }
       if (spec.shading) {
-        requirePixelLabOption("shading", spec.shading, [
+        requirePixelLabOption("terrain", "shading", spec.shading, [
           "flat shading",
           "basic shading",
           "medium shading",
@@ -2866,7 +3116,7 @@ var PixelLabProvider = class _PixelLabProvider {
         ]);
       }
       if (spec.detail) {
-        requirePixelLabOption("detail", spec.detail, ["low detail", "medium detail", "highly detailed"]);
+        requirePixelLabOption("terrain", "detail", spec.detail, ["low detail", "medium detail", "highly detailed"]);
       }
       if (spec.terrainShapeStyle && spec.terrainMode === "pro") {
         throw new Error(
@@ -2887,7 +3137,32 @@ var PixelLabProvider = class _PixelLabProvider {
         );
       }
     }
+    if (spec.generator === "isometricTile") {
+      if (spec.outline) {
+        requirePixelLabOption("isometricTile", "outline", spec.outline, [
+          "single color outline",
+          "selective outline",
+          "lineless"
+        ]);
+      }
+      if (spec.shading) {
+        requirePixelLabOption("isometricTile", "shading", spec.shading, [
+          "flat shading",
+          "basic shading",
+          "medium shading",
+          "detailed shading",
+          "highly detailed shading"
+        ]);
+      }
+      if (spec.detail) {
+        requirePixelLabOption("isometricTile", "detail", spec.detail, ["low detail", "medium detail", "highly detailed"]);
+      }
+      if (spec.width < 16 || spec.width > 64) {
+        throw new Error(`PixelLab isometricTile: size must be 16 to 64 pixels, got ${spec.width}`);
+      }
+    }
     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`);
     }
@@ -2901,6 +3176,11 @@ var PixelLabProvider = class _PixelLabProvider {
         "PixelLab imagePro does not support style images yet; /generate-image-v2's own reference_images and style_image are not modeled here"
       );
     }
+    if (spec.generator === "isometricTile" && styleImages.length) {
+      throw new Error(
+        "PixelLab isometricTile does not support style images; /create-isometric-tile has no such field (its own init_image/color_image are not modeled here yet)"
+      );
+    }
     for (const image of styleImages) {
       if (image.width > 256 || image.height > 256) {
         throw new Error(
@@ -3043,6 +3323,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 && (0, import_node_fs2.existsSync)(object.parentFile) ? imageMetadata((0, import_node_fs2.readFileSync)(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
@@ -3136,6 +3473,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);
@@ -3219,10 +3628,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({
@@ -3283,6 +3775,20 @@ var PixelLabProvider = class _PixelLabProvider {
       });
       return { jobId: res2.tileset_id, metadata: { backgroundJobId: res2.background_job_id } };
     }
+    if (spec.generator === "isometricTile") {
+      const res2 = await this.client.createIsometricTile({
+        description: spec.prompt,
+        imageWidth: spec.width,
+        imageHeight: spec.height,
+        tileSize: spec.isometricTileSize,
+        tileShape: spec.isometricTileShape,
+        outline: spec.outline,
+        shading: spec.shading,
+        detail: spec.detail,
+        seed: spec.seed
+      });
+      return { jobId: res2.tile_id, metadata: { backgroundJobId: res2.background_job_id } };
+    }
     if (spec.generator === "imagePro") {
       const res2 = await this.client.createImagePro({
         description: spec.prompt,
@@ -3399,8 +3905,10 @@ var PixelLabProvider = class _PixelLabProvider {
     if (generator === "map") return this.pollMap(jobId, context);
     if (generator === "tiles") return this.pollTiles(jobId, Boolean(context?.tileFeature), context);
     if (generator === "terrain") return this.pollTerrain(jobId, context);
+    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") {
@@ -3609,6 +4117,31 @@ var PixelLabProvider = class _PixelLabProvider {
       throw err;
     }
   }
+  /**
+   * `/create-isometric-tile` reports progress the same way `/create-tileset`
+   * does (423 while drawing, 200 once finished, no `status` field to poll),
+   * and its image also comes back embedded as base64 rather than a
+   * `storage_urls` link. One call is one tile with nothing to review, so
+   * this goes straight to "ready" like a connectable `tiles`/`terrain` set.
+   */
+  async pollIsometricTile(tileId, context) {
+    try {
+      const { image, usage } = await this.client.getIsometricTile(tileId);
+      const backgroundJobId = context?.metadata?.backgroundJobId;
+      const billed = billedFromUsage(usage) ?? await this.billedForJob(backgroundJobId);
+      const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${tileId}.png`);
+      (0, import_node_fs2.writeFileSync)(file, Buffer.from(image.base64, "base64"));
+      return {
+        status: "ready",
+        objectId: tileId,
+        sourceUrl: `file://${file}`,
+        billed
+      };
+    } catch (err) {
+      if (err instanceof PixelLabError && err.status === 423) return { status: "processing" };
+      throw err;
+    }
+  }
   async selectCandidate(jobId, index, commonTag, generator) {
     if (generator === "tiles") {
       const set = await this.client.getTilesPro(jobId);
@@ -3725,9 +4258,9 @@ function remoteCharacter(character) {
     animationCount: character.animation_count
   };
 }
-function requirePixelLabOption(name, value, allowed) {
+function requirePixelLabOption(generator, name, value, allowed) {
   if (value != null && !allowed.includes(value)) {
-    throw new Error(`PixelLab map ${name} must be one of: ${allowed.join(", ")}`);
+    throw new Error(`PixelLab ${generator} ${name} must be one of: ${allowed.join(", ")}`);
   }
 }
 function tilesInIndexOrder(urls) {
@@ -3793,6 +4326,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_URL = "https://api.retrodiffusion.ai/v1";
@@ -6346,14 +6901,22 @@ async function resolveSpecs(loaded, filter) {
         size = style.terrainTileSize ?? 16;
         width = size;
         height = size;
+      } else if (generator === "isometricTile") {
+        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";
@@ -6374,7 +6937,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(", ");
@@ -6439,8 +7002,11 @@ async function resolveSpecs(loaded, filter) {
         terrainRaggedness: generator === "terrain" ? style.terrainRaggedness : void 0,
         terrainTransitionSize: generator === "terrain" ? style.terrainTransitionSize : void 0,
         terrainView: generator === "terrain" ? style.terrainView : void 0,
+        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 }) } : {},
-        cost: generator === "tiles" ? tilesCost(tileSize, tileVariations) : generator === "terrain" ? tilesCost(size, terrainTiles) : generationCost(width, height, generator),
+        ...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
       };
@@ -6505,6 +7071,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;
@@ -6546,6 +7124,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: (0, import_node_fs5.existsSync)(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(
@@ -6731,6 +7326,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: import_node_path5.default.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: import_node_path5.default.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;
+}
 function characterDirections(directions) {
   return directions === 4 ? CHARACTER_DIRECTIONS_4 : CHARACTER_DIRECTIONS_8;
 }
@@ -8207,6 +8856,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());
 }
@@ -8248,6 +8898,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 || !(0, import_node_fs8.existsSync)(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" };
@@ -8299,6 +8967,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" } : {
@@ -8343,7 +9015,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) {
@@ -11004,7 +11677,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];
@@ -15239,6 +15913,7 @@ async function workspaceStatus(ws, dir) {
   isFrameSetEntry,
   isMemberSetEntry,
   isSensitiveSourceUrl,
+  isometricTileCost,
   listBundledRecipes,
   loadClaims,
   loadLock,