pixelkiln 0.43.0 → 0.45.0

package/dist/index.cjs

@@ -427,11 +427,45 @@ var CharacterAnimationSchema = import_zod.z.object({
   /** v3 only: keep the resting pose as frame 0, so `frames` generated frames land as `frames + 1` files. */
   keepFirstFrame: import_zod.z.boolean().default(true),
   /** `template` when a template is named, otherwise `v3`; `pro` for the sequential high-quality engine. */
-  mode: CharacterAnimationModeSchema.optional()
+  mode: CharacterAnimationModeSchema.optional(),
+  /**
+   * v3 only: a manifest-relative image of the pose to start from, instead
+   * of the character's rotation for this direction. Up to 256px.
+   */
+  startFrame: import_zod.z.string().min(1).optional(),
+  /**
+   * v3 only: a pose to animate toward. The loop then interpolates from the
+   * start frame (the rotation, or `startFrame`) to this image, which must
+   * be the same size as the start frame.
+   */
+  endFrame: import_zod.z.string().min(1).optional(),
+  /** What is being animated, when the character's own description would mislead the model. */
+  subject: import_zod.z.string().min(1).optional(),
+  /** Template mode only: style hints for this loop, over the character's own. */
+  outline: import_zod.z.string().min(1).optional(),
+  shading: import_zod.z.string().min(1).optional(),
+  detail: import_zod.z.string().min(1).optional(),
+  /** v3 text loops only: let PixelLab expand the action into a fuller motion description first. */
+  enhancePrompt: import_zod.z.boolean().optional()
 }).strict().superRefine((animation, context) => {
   if (animation.frames !== void 0 && animation.frames % 2 !== 0) {
     context.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: "frames must be even", path: ["frames"] });
   }
+  const mode2 = animation.mode ?? (animation.template ? "template" : "v3");
+  for (const key of ["startFrame", "endFrame", "enhancePrompt"]) {
+    if (animation[key] !== void 0 && mode2 !== "v3") {
+      context.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: `${key} is for v3 loops; a ${mode2} loop ${mode2 === "template" ? "starts from the character's rotation and follows its template" : "takes neither"}`,
+        path: [key]
+      });
+    }
+  }
+  for (const key of ["outline", "shading", "detail"]) {
+    if (animation[key] !== void 0 && mode2 !== "template") {
+      context.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: `${key} overrides apply to template loops only`, path: [key] });
+    }
+  }
   if (animation.template && animation.mode && animation.mode !== "template") {
     context.addIssue({
       code: import_zod.z.ZodIssueCode.custom,
@@ -569,6 +603,14 @@ var StyleObjectSchema = import_zod.z.object({
   textGuidanceScale: import_zod.z.number().min(1).max(20).optional(),
   /** `character` only. Draw `standard` bases and every loop in isometric view. */
   isometric: import_zod.z.boolean().optional(),
+  /** `character` only, `v3` bases: let PixelLab expand the prompt into a fuller one before drawing. */
+  enhancePrompt: import_zod.z.boolean().optional(),
+  /**
+   * `character` only, `pro` bases: the asset id of a generated 8-direction
+   * character in this style whose look every base drawn from text or a
+   * concept follows. An asset may override it; the anchor itself ignores it.
+   */
+  styleCharacter: import_zod.z.string().min(1).optional(),
   /** Fixed seed for reproducibility where the endpoint supports it. */
   seed: import_zod.z.number().int().optional(),
   /**
@@ -741,6 +783,15 @@ var AssetSchema = import_zod.z.object({
    * 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(),
+  /**
+   * `character` styles, `pro` bases only: a manifest-relative concept
+   * image (a painting, a photo, a sketch; up to 1024px) that seeds the
+   * design instead of the prompt alone. A style image or `styleCharacter`
+   * may still anchor the look.
+   */
+  concept: import_zod.z.string().min(1).optional(),
+  /** `character` styles, `pro` bases: this base's style anchor, over the style's. */
+  styleCharacter: import_zod.z.string().min(1).optional(),
   /**
    * Another asset of the same style flipped left to right, made locally
    * from that asset's downloaded files at no generation cost.
@@ -822,6 +873,20 @@ var AssetSchema = import_zod.z.object({
       path: ["reference"]
     });
   }
+  if (asset.concept && (asset.state || asset.animation || asset.mirror)) {
+    context.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "a concept image belongs on a base; a state, animation, or mirror takes its look from its parent",
+      path: ["concept"]
+    });
+  }
+  if (asset.concept && asset.reference) {
+    context.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "concept and reference are mutually exclusive: a concept seeds a new design, a reference is the sprite to rotate",
+      path: ["concept"]
+    });
+  }
   if (typeof asset.reference === "object" && !Object.keys(asset.reference).length) {
     context.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: "a reference needs at least a south image", path: ["reference"] });
   }
@@ -1493,7 +1558,8 @@ var PixelLabClient = class {
         ...args.outline ? { outline: args.outline } : {},
         ...args.detail ? { detail: args.detail } : {},
         ...args.seed != null ? { seed: args.seed } : {},
-        ...south ? { reference_image: encode(south) } : {}
+        ...south ? { reference_image: encode(south) } : {},
+        ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro") {
       path33 = "/create-character-pro";
@@ -1502,10 +1568,12 @@ var PixelLabClient = class {
         image_size: imageSize,
         template_id: args.template,
         no_background: args.noBackground ?? true,
-        method: south ? "rotate_character" : "create_with_style",
+        method: south ? "rotate_character" : args.concept ? "create_from_concept" : "create_with_style",
         ...args.view ? { view: args.view } : {},
         ...args.seed != null ? { seed: args.seed } : {},
-        ...south ? { reference_image: encode(south) } : args.styleReference ? { reference_image: encode(args.styleReference) } : {}
+        ...south ? { reference_image: encode(south) } : args.styleReference ? { reference_image: encode(args.styleReference) } : {},
+        ...!south && args.concept ? { concept_image: encode(args.concept) } : {},
+        ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
       path33 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
@@ -1550,6 +1618,7 @@ var PixelLabClient = class {
    * the action text; pro is the sequential engine. One job per direction.
    */
   async animateCharacter(args) {
+    const encode = (image) => ({ type: "base64", base64: image.base64, format: image.format });
     const raw = await this.request("/animate-character", {
       method: "POST",
       body: JSON.stringify({
@@ -1559,10 +1628,18 @@ var PixelLabClient = class {
         directions: args.directions,
         ...args.template ? { template_animation_id: args.template } : {},
         ...args.actionDescription ? { action_description: args.actionDescription } : {},
+        ...args.description ? { description: args.description } : {},
         ...args.mode === "v3" && args.frameCount ? { frame_count: args.frameCount } : {},
         ...args.mode === "v3" && args.keepFirstFrame === false ? { keep_first_frame: false } : {},
+        ...args.mode === "v3" && args.startFrame ? { custom_start_frame: encode(args.startFrame) } : {},
+        ...args.mode === "v3" && args.endFrame ? { end_frame: encode(args.endFrame) } : {},
+        ...args.mode === "v3" && args.enhancePrompt ? { enhance_prompt: true } : {},
         ...args.mode === "template" && args.textGuidanceScale !== void 0 ? { text_guidance_scale: args.textGuidanceScale } : {},
+        ...args.mode === "template" && args.outline ? { outline: args.outline } : {},
+        ...args.mode === "template" && args.shading ? { shading: args.shading } : {},
+        ...args.mode === "template" && args.detail ? { detail: args.detail } : {},
         ...args.isometric !== void 0 ? { isometric: args.isometric } : {},
+        ...args.paletteSwatchBase64 ? { color_image: { type: "base64", base64: args.paletteSwatchBase64, format: "png" }, force_colors: true } : {},
         ...args.seed != null ? { seed: args.seed } : {}
       })
     });
@@ -2159,6 +2236,34 @@ function skipSubBlocks(bytes, start) {
 function cacheFileName(hash, mediaType = MediaType.PNG) {
   return `${hash}${mediaExtension(mediaType)}`;
 }
+function imageMetadata(buf) {
+  if (buf.length >= 24 && buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834 && buf.toString("ascii", 12, 16) === "IHDR") {
+    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20), format: "png" };
+  }
+  if (buf.length < 4 || buf[0] !== 255 || buf[1] !== 216) return null;
+  let offset = 2;
+  while (offset + 3 < buf.length) {
+    if (buf[offset] !== 255) return null;
+    while (buf[offset] === 255) offset++;
+    const marker = buf[offset++];
+    if (marker == null || marker === 217 || marker === 218) break;
+    if (marker === 1 || marker >= 208 && marker <= 215) continue;
+    if (offset + 2 > buf.length) return null;
+    const length = buf.readUInt16BE(offset);
+    if (length < 2 || offset + length > buf.length) return null;
+    const isStartOfFrame = marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker);
+    if (isStartOfFrame) {
+      if (length < 7) return null;
+      return {
+        width: buf.readUInt16BE(offset + 5),
+        height: buf.readUInt16BE(offset + 3),
+        format: "jpeg"
+      };
+    }
+    offset += length;
+  }
+  return null;
+}
 
 // src/providers/pixellab.ts
 var import_node_fs2 = require("fs");
@@ -2219,12 +2324,20 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
         parent: spec.character.parentAssetId,
         parentSha256: spec.character.parentSha256 ?? null,
         state: spec.character.state,
-        animation: spec.character.animation,
+        // Pose images enter as their hashes, never their paths.
+        animation: spec.character.animation ? {
+          ...spec.character.animation,
+          startFrame: spec.character.animation.startFrame?.sha256,
+          endFrame: spec.character.animation.endFrame?.sha256
+        } : void 0,
         // Absent keys keep the hashes of manifests that never set these.
         proportions: spec.character.proportions,
         textGuidanceScale: spec.character.textGuidanceScale,
         isometric: spec.character.isometric,
-        reference: spec.character.reference ? Object.fromEntries(Object.entries(spec.character.reference).map(([direction, image]) => [direction, image.sha256])) : void 0
+        enhancePrompt: spec.character.enhancePrompt,
+        reference: spec.character.reference ? Object.fromEntries(Object.entries(spec.character.reference).map(([direction, image]) => [direction, image.sha256])) : void 0,
+        concept: spec.character.concept?.sha256,
+        styleAnchor: spec.character.styleAnchor ? { of: spec.character.styleAnchor.assetId, sha256: spec.character.styleAnchor.sha256 } : void 0
       } : 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.
@@ -2392,6 +2505,38 @@ var PixelLabProvider = class _PixelLabProvider {
         throw new Error(`${label}: proportions apply to the mannequin template; ${character.template} is a quadruped`);
       }
     }
+    if (character.kind === "base" && character.enhancePrompt !== void 0 && character.mode !== "v3") {
+      throw new Error(`${label}: enhancePrompt applies to v3 bases; the ${character.mode} engine does not take it`);
+    }
+    if (character.animation) {
+      const { startFrame, endFrame } = character.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 ?? (character.parentFile && (0, import_node_fs2.existsSync)(character.parentFile) ? imageMetadata((0, import_node_fs2.readFileSync)(character.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" : "character's rotation"} is ${start.width}x${start.height}; PixelLab interpolates between frames of one size`
+          );
+        }
+      }
+    }
+    if (character.concept) {
+      if (character.mode !== "pro") throw new Error(`${label}: a concept image is a pro input; the ${character.mode} engine draws from text or a reference`);
+      if (character.concept.width > 1024 || character.concept.height > 1024) {
+        throw new Error(`${label}: concept image is ${character.concept.width}x${character.concept.height}; PixelLab pro takes up to 1024px`);
+      }
+    }
+    if (character.styleAnchor) {
+      if (character.mode !== "pro") throw new Error(`${label}: styleCharacter is a pro input; the ${character.mode} engine has no style anchor`);
+      if (character.reference) throw new Error(`${label}: a pro base rotating its own reference takes no styleCharacter`);
+      if (character.styleAnchor.spec.character?.directions !== 8) {
+        throw new Error(`${label}: styleCharacter ${character.styleAnchor.assetId} has ${character.styleAnchor.spec.character?.directions} directions; PixelLab wants an 8-direction anchor`);
+      }
+    }
     if (character.reference) {
       const given = Object.keys(character.reference);
       if (!character.reference.south) throw new Error(`${label}: a reference needs a south-facing sprite`);
@@ -2492,7 +2637,10 @@ var PixelLabProvider = class _PixelLabProvider {
         textGuidanceScale: character.textGuidanceScale,
         isometric: character.isometric,
         reference: character.reference ? readReference(spec, character.reference) : void 0,
-        styleReference: styleImage ? { base64: styleImage.base64, format: styleImage.format } : void 0
+        styleReference: styleImage ? { base64: styleImage.base64, format: styleImage.format } : void 0,
+        enhancePrompt: character.enhancePrompt,
+        concept: character.concept ? readPose(spec, "concept image", character.concept) : void 0,
+        styleCharacterId: character.styleAnchor ? requireStyleObjectId(spec, context) : void 0
       });
       return { jobId: res2.character_id, metadata: { character: { kind: "base", characterId: res2.character_id, mode: character.mode, directions: character.directions, backgroundJobId: res2.background_job_id } } };
     }
@@ -2536,7 +2684,15 @@ var PixelLabProvider = class _PixelLabProvider {
       directions: [animation.direction],
       seed: spec.seed,
       textGuidanceScale: character.textGuidanceScale,
-      isometric: character.isometric
+      isometric: character.isometric,
+      startFrame: animation.startFrame ? readPose(spec, "start frame", animation.startFrame) : void 0,
+      endFrame: animation.endFrame ? readPose(spec, "end frame", animation.endFrame) : void 0,
+      description: animation.subject,
+      outline: animation.outline,
+      shading: animation.shading,
+      detail: animation.detail,
+      enhancePrompt: animation.enhancePrompt,
+      paletteSwatchBase64: spec.palette.length ? paletteSwatch(spec.palette).toString("base64") : void 0
     });
     const job = { characterId: parentId, name, direction: animation.direction, jobIds: res.background_job_ids };
     return {
@@ -2904,6 +3060,21 @@ function readReference(spec, reference) {
   }
   return images;
 }
+function requireStyleObjectId(spec, context) {
+  if (!context?.styleObjectId) {
+    throw new Error(
+      `${spec.styleId}/${spec.assetId} anchors its style on ${spec.character.styleAnchor.assetId}, which has no PixelLab character id in the lockfile yet; generate the anchor first`
+    );
+  }
+  return context.styleObjectId;
+}
+function readPose(spec, what, image) {
+  const bytes = (0, import_node_fs2.readFileSync)(image.path);
+  if (sha256(bytes) !== image.sha256) {
+    throw new Error(`${spec.styleId}/${spec.assetId}: ${what} changed after the manifest was resolved: ${image.path}`);
+  }
+  return { base64: bytes.toString("base64"), format: image.format };
+}
 function rotationSources(character) {
   const order = character.directions === 4 ? CHARACTER_DIRECTIONS_4 : CHARACTER_DIRECTIONS_8;
   const sources = [];
@@ -5596,6 +5767,18 @@ async function resolveSpecs(loaded, filter) {
         finalized.add(assetId);
         return resolved;
       }
+      const anchorId = asset.styleCharacter ?? style.styleCharacter;
+      if (resolved.character?.kind === "base" && anchorId && anchorId !== assetId) {
+        const anchorSpec = await finalize(anchorId);
+        if (!anchorSpec.character || anchorSpec.character.kind === "animation") {
+          throw new Error(`assets.${assetId}: styleCharacter ${anchorId} is not a character base or state`);
+        }
+        const file = memberPath(anchorSpec.outFile, "south", 0, anchorSpec.character.directions, MediaType.PNG);
+        resolved.character = {
+          ...resolved.character,
+          styleAnchor: { assetId: anchorId, spec: anchorSpec, file, sha256: (0, import_node_fs5.existsSync)(file) ? await sha256File(file) : null }
+        };
+      }
       const characterParent = asset.state?.of ?? asset.animation?.of;
       if (resolved.character && characterParent) {
         const parentSpec = await finalize(characterParent);
@@ -5734,34 +5917,6 @@ async function resolveStyleImages(loaded, styleId) {
 async function styleImagesBase64(loaded, styleId) {
   return (await resolveStyleImages(loaded, styleId)).map((img) => img.base64);
 }
-function imageMetadata(buf) {
-  if (buf.length >= 24 && buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834 && buf.toString("ascii", 12, 16) === "IHDR") {
-    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20), format: "png" };
-  }
-  if (buf.length < 4 || buf[0] !== 255 || buf[1] !== 216) return null;
-  let offset = 2;
-  while (offset + 3 < buf.length) {
-    if (buf[offset] !== 255) return null;
-    while (buf[offset] === 255) offset++;
-    const marker = buf[offset++];
-    if (marker == null || marker === 217 || marker === 218) break;
-    if (marker === 1 || marker >= 208 && marker <= 215) continue;
-    if (offset + 2 > buf.length) return null;
-    const length = buf.readUInt16BE(offset);
-    if (length < 2 || offset + length > buf.length) return null;
-    const isStartOfFrame = marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker);
-    if (isStartOfFrame) {
-      if (length < 7) return null;
-      return {
-        width: buf.readUInt16BE(offset + 5),
-        height: buf.readUInt16BE(offset + 3),
-        format: "jpeg"
-      };
-    }
-    offset += length;
-  }
-  return null;
-}
 async function resolveCharacterShape(asset, style, kind, files) {
   const mode2 = style.mode ?? "standard";
   const directions = mode2 === "standard" ? style.directions ?? 8 : 8;
@@ -5773,8 +5928,13 @@ async function resolveCharacterShape(asset, style, kind, files) {
     template: style.template ?? "mannequin",
     ...proportions !== void 0 ? { proportions } : {},
     ...style.textGuidanceScale !== void 0 ? { textGuidanceScale: style.textGuidanceScale } : {},
-    ...style.isometric !== void 0 ? { isometric: style.isometric } : {}
+    ...style.isometric !== void 0 ? { isometric: style.isometric } : {},
+    ...style.enhancePrompt !== void 0 ? { enhancePrompt: style.enhancePrompt } : {}
   };
+  if (asset.concept) {
+    const image = await files.load(asset.concept, "Concept image");
+    shape.concept = { path: import_node_path5.default.resolve(files.root, asset.concept), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+  }
   if (asset.reference) {
     const byDirection = typeof asset.reference === "string" ? { south: asset.reference } : asset.reference;
     shape.reference = {};
@@ -5797,13 +5957,24 @@ async function resolveCharacterShape(asset, style, kind, files) {
   }
   if (asset.animation) {
     const animationMode = asset.animation.mode ?? (asset.animation.template ? "template" : "v3");
+    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: animationMode,
       ...asset.animation.template ? { template: asset.animation.template } : {},
       direction: asset.animation.direction,
       frames: asset.animation.frames ?? 8,
       fps: asset.animation.fps,
-      keepFirstFrame: asset.animation.keepFirstFrame
+      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.subject ? { subject: asset.animation.subject } : {},
+      ...asset.animation.outline ? { outline: asset.animation.outline } : {},
+      ...asset.animation.shading ? { shading: asset.animation.shading } : {},
+      ...asset.animation.detail ? { detail: asset.animation.detail } : {},
+      ...asset.animation.enhancePrompt !== void 0 ? { enhancePrompt: asset.animation.enhancePrompt } : {}
     };
   }
   return shape;
@@ -7283,9 +7454,24 @@ var import_node_path11 = __toESM(require("path"), 1);
 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.revision) return null;
   return inspectRevision(spec, lock, /* @__PURE__ */ new Set());
 }
+async function inspectStyleAnchor(spec, lock, seen) {
+  const anchor = spec.character.styleAnchor;
+  const label = `style anchor ${spec.styleId}/${anchor.assetId}`;
+  const dependency = await inspectParent(anchor.spec, lock, seen);
+  if (!dependency.ready) return { ready: false, reason: `${label} is not ready: ${dependency.reason}` };
+  if (!anchor.sha256 || !(0, import_node_fs8.existsSync)(anchor.file)) return { ready: false, reason: `${label} has no generated south-facing file yet` };
+  if (await sha256File(anchor.file) !== anchor.sha256) {
+    return { ready: false, reason: `${label} changed after the manifest was resolved` };
+  }
+  if (!lock.entries[lockKey(anchor.spec.styleId, anchor.spec.assetId)]?.objectId) {
+    return { ready: false, reason: `${label} has no PixelLab character id recorded` };
+  }
+  return { ready: true, reason: `${label} is current` };
+}
 async function inspectMirror(spec, lock, seen) {
   const source = spec.mirror.sourceSpec;
   const label = `mirror source ${spec.styleId}/${spec.mirror.sourceAssetId}`;
@@ -7357,6 +7543,10 @@ async function inspectParent(spec, lock, seen) {
     const inputs = await inspectCharacterParent(spec, lock, nextSeen);
     if (!inputs.ready) return inputs;
   }
+  if (spec.character?.styleAnchor) {
+    const inputs = await inspectStyleAnchor(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" } : {
@@ -7396,6 +7586,14 @@ async function anyOutputModified(entry, spec) {
   }
   return false;
 }
+function dependencies(spec) {
+  return [
+    spec.mirror?.sourceSpec,
+    spec.revision?.sourceSpec,
+    spec.character?.parentSpec,
+    spec.character?.styleAnchor?.spec
+  ].filter((parent) => Boolean(parent));
+}
 function resumeCommandForStatus(status) {
   if (status === "pending" || status === "processing") return "poll";
   if (status === "review") return "pick";
@@ -7504,16 +7702,19 @@ async function buildPlan(specs, lock, opts = {}) {
   const stateOf = new Map(items.map((i) => [i.key, i.state]));
   for (const item of items) {
     if (!isActionable(item)) continue;
-    const parent = item.spec.mirror?.sourceSpec ?? item.spec.revision?.sourceSpec ?? item.spec.character?.parentSpec;
-    if (!parent) continue;
-    const parentKey = lockKey(parent.styleId, parent.assetId);
-    const parentState = stateOf.get(parentKey);
-    if (parentState && isActionable({ state: parentState })) {
-      item.state = "blocked";
-      item.reason = `parent ${parentKey} is being generated in this run; this follows in the next wave`;
-    } else if (item.spec.mirror && (parentState === "recoverable" || parentState === "in-flight")) {
-      item.state = "blocked";
-      item.reason = `mirror source ${parentKey} is ${parentState}; this follows in the next wave`;
+    for (const parent of dependencies(item.spec)) {
+      const parentKey = lockKey(parent.styleId, parent.assetId);
+      const parentState = stateOf.get(parentKey);
+      if (parentState && isActionable({ state: parentState })) {
+        item.state = "blocked";
+        item.reason = `parent ${parentKey} is being generated in this run; this follows in the next wave`;
+        break;
+      }
+      if (item.spec.mirror && (parentState === "recoverable" || parentState === "in-flight")) {
+        item.state = "blocked";
+        item.reason = `mirror source ${parentKey} is ${parentState}; this follows in the next wave`;
+        break;
+      }
     }
   }
   const actionable = items.filter(isActionable);
@@ -9992,10 +10193,13 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
     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 anchor = spec.character?.styleAnchor;
+      const anchorEntry = anchor ? lock.entries[lockKey(anchor.spec.styleId, anchor.spec.assetId)] : void 0;
       const replacedMetadata = previousEntry?.providerMetadata?.[provider.id];
       const { jobId, metadata } = await provider.submit(spec, refs, {
         ...previousJobId ? { previousJobId } : {},
         ...parentEntry?.objectId ? { parentObjectId: parentEntry.objectId } : {},
+        ...anchorEntry?.objectId ? { styleObjectId: anchorEntry.objectId } : {},
         ...replacedMetadata ? { replacedMetadata } : {},
         ...previousMetadata ? { previousMetadata } : {},
         checkpoint: async (checkpoint) => {
@@ -12604,7 +12808,7 @@ var pin_default = {
   godot: "4.7.2",
   extensionsApi: 9,
   protocol: 4,
-  release: "editor-pixelorama-v1.2.2-pk.18",
+  release: "editor-pixelorama-v1.2.2-pk.26",
   files: {
     "index.apple-touch-icon.png": {
       sha256: "ee5434873e0fed91e9a888c3ea5a8b79beac25999308be7a6eb41bf4ce640d27",
@@ -12619,7 +12823,7 @@ var pin_default = {
       bytes: 7298
     },
     "index.html": {
-      sha256: "d9adf06036660c4b76ef5386e872bc03dc0d5b0628fd6ac660d480893ee1f47a",
+      sha256: "326101ab02bb4a29a7964214c9307c7dff26e9d66b8ebaaf6e7a3987e84a05b2",
       bytes: 5442
     },
     "index.icon.png": {
@@ -12631,8 +12835,8 @@ var pin_default = {
       bytes: 279815
     },
     "index.pck": {
-      sha256: "a41d9c3a39aa99ea5ee49ddcedfeb8b092006aa75c0de67139f13297c17f42e4",
-      bytes: 6431692
+      sha256: "e26292650bb996965acd1ba70e74d2b4020b063d14f1276701312c1d34cb0a83",
+      bytes: 6431932
     },
     "index.png": {
       sha256: "6e3ca3eb4a99e4c07bdd89ebc873b440ec0ffd66ce1955160da9e7ed80d538d7",