pixelkiln 0.87.0 → 0.88.0

package/dist/index.cjs

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   AssetBatchSchema: () => AssetBatchSchema,
   AssetSchema: () => AssetSchema,
+  AssetVfxSchema: () => AssetVfxSchema,
   BudgetError: () => BudgetError,
   CHARACTER_DIRECTIONS_4: () => CHARACTER_DIRECTIONS_4,
   CHARACTER_DIRECTIONS_8: () => CHARACTER_DIRECTIONS_8,
@@ -88,12 +89,14 @@ __export(index_exports, {
   OverwriteRefusedError: () => OverwriteRefusedError,
   PIXELATE_COST_GENERATIONS: () => PIXELATE_COST_GENERATIONS,
   PIXELATE_MAX_SIDE: () => PIXELATE_MAX_SIDE,
+  PIXELLAB_MCP_URL: () => PIXELLAB_MCP_URL,
   PIXEL_ART_FIXER_REVISION: () => PIXEL_ART_FIXER_REVISION,
   PIXEL_ART_FIXER_URL: () => PIXEL_ART_FIXER_URL,
   PRO_TIER_PRICES: () => PRO_TIER_PRICES,
   PixelKilnError: () => PixelKilnError,
   PixelLabClient: () => PixelLabClient,
   PixelLabError: () => PixelLabError,
+  PixelLabMcpClient: () => PixelLabMcpClient,
   PixelLabProvider: () => PixelLabProvider,
   PostprocessSchema: () => PostprocessSchema,
   ProjectError: () => ProjectError,
@@ -116,12 +119,15 @@ __export(index_exports, {
   UiPieceSchema: () => UiPieceSchema,
   UnsupportedCapabilityError: () => UnsupportedCapabilityError,
   UsageError: () => UsageError,
+  VFX_TOOL: () => VFX_TOOL,
+  VfxPartSchema: () => VfxPartSchema,
   WorkspaceProjectSchema: () => WorkspaceProjectSchema,
   WorkspaceSchema: () => WorkspaceSchema,
   adopt: () => adopt,
   applyManifestEdit: () => applyManifestEdit,
   applyTags: () => applyTags,
   approveQualityRecord: () => approveQualityRecord,
+  assetInStyle: () => assetInStyle,
   auditStyle: () => auditStyle,
   availableProviders: () => availableProviders,
   backoffMs: () => backoffMs,
@@ -148,6 +154,7 @@ __export(index_exports, {
   defaultOpenCommand: () => defaultOpenCommand,
   defaultPixelateOut: () => defaultPixelateOut,
   defaultUnzoomOut: () => defaultUnzoomOut,
+  describeVfx: () => describeVfx,
   detachHandEdit: () => detachHandEdit,
   detectMediaType: () => detectMediaType,
   doctor: () => doctor,
@@ -168,6 +175,7 @@ __export(index_exports, {
   fontOutputPaths: () => fontOutputPaths,
   formatCost: () => formatCost,
   frameSetFps: () => frameSetFps,
+  frameSetLoop: () => frameSetLoop,
   galleryContentSecurityPolicy: () => galleryContentSecurityPolicy,
   galleryMediaId: () => galleryMediaId,
   galleryMediaRoute: () => galleryMediaRoute,
@@ -190,9 +198,11 @@ __export(index_exports, {
   inspectRevisionReadiness: () => inspectRevisionReadiness,
   installEditor: () => installEditor,
   installRecipe: () => installRecipe,
+  isBusyReply: () => isBusyReply,
   isFrameSetEntry: () => isFrameSetEntry,
   isMemberSetEntry: () => isMemberSetEntry,
   isSensitiveSourceUrl: () => isSensitiveSourceUrl,
+  isVfxReference: () => isVfxReference,
   isometricTileCost: () => isometricTileCost,
   listBundledRecipes: () => listBundledRecipes,
   loadClaims: () => loadClaims,
@@ -201,7 +211,9 @@ __export(index_exports, {
   loadSiblingManifests: () => loadSiblingManifests,
   loadWorkspace: () => loadWorkspace,
   lockKey: () => lockKey,
+  makeVfx: () => makeVfx,
   matchOrphanStyle: () => matchOrphanStyle,
+  mcpClientFromEnv: () => mcpClientFromEnv,
   measureBalanceChange: () => measureBalanceChange,
   measureDecodedImageQuality: () => measureDecodedImageQuality,
   measureImageQuality: () => measureImageQuality,
@@ -225,8 +237,12 @@ __export(index_exports, {
   paletteDistance: () => paletteDistance,
   parentAssetId: () => parentAssetId,
   parseLock: () => parseLock,
+  parseMcpBody: () => parseMcpBody,
   parseProFlashQuote: () => parseProFlashQuote,
   parseTerrainDescriptions: () => parseTerrainDescriptions,
+  parseVfxExport: () => parseVfxExport,
+  parseVfxRecipe: () => parseVfxRecipe,
+  parseVfxStep: () => parseVfxStep,
   parseWorkspace: () => parseWorkspace,
   pickHistory: () => pickHistory,
   pixelateFile: () => pixelateFile,
@@ -246,6 +262,8 @@ __export(index_exports, {
   readArtifactBundleManifest: () => readArtifactBundleManifest,
   readHandEditCompanion: () => readHandEditCompanion,
   readQualityBaseline: () => readQualityBaseline,
+  readSavedVfxRecipe: () => readSavedVfxRecipe,
+  readVfxRecipe: () => readVfxRecipe,
   recipeDigest: () => recipeDigest,
   referencedHashes: () => referencedHashes,
   refineAsset: () => refineAsset,
@@ -276,6 +294,7 @@ __export(index_exports, {
   resolveSpecs: () => resolveSpecs,
   resolveStyleImages: () => resolveStyleImages,
   resolveStyleOutputs: () => resolveStyleOutputs,
+  resolveVfxSprite: () => resolveVfxSprite,
   resumeActions: () => resumeActions,
   resumeCommandForStatus: () => resumeCommandForStatus,
   retireGeneration: () => retireGeneration,
@@ -283,6 +302,7 @@ __export(index_exports, {
   revertGeneration: () => revertGeneration,
   runPicker: () => runPicker,
   runSalvage: () => runSalvage,
+  runVfxWorkbench: () => runVfxWorkbench,
   saveHandEdit: () => saveHandEdit,
   saveLock: () => saveLock,
   saveWorkspace: () => saveWorkspace,
@@ -293,6 +313,7 @@ __export(index_exports, {
   sha256File: () => sha256File,
   shouldPersistSourceUrl: () => shouldPersistSourceUrl,
   shouldRetry: () => shouldRetry,
+  sliceVfxSheet: () => sliceVfxSheet,
   slugify: () => slugify,
   snapshotQualityBaseline: () => snapshotQualityBaseline,
   sourceIsStem: () => sourceIsStem,
@@ -317,6 +338,8 @@ __export(index_exports, {
   validateWorkspace: () => validateWorkspace,
   verifyArtifactBundle: () => verifyArtifactBundle,
   verifyRecipe: () => verifyRecipe,
+  vfxOutputPaths: () => vfxOutputPaths,
+  vfxRecipeSha256: () => vfxRecipeSha256,
   withArtifactManifest: () => withArtifactManifest,
   workspaceClaims: () => workspaceClaims,
   workspaceStatus: () => workspaceStatus,
@@ -332,7 +355,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", "isometricTile", "objectPro", "uiAsset", "uiElement", "imageProFlash"]);
+var GeneratorSchema = import_zod.z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro", "isometricTile", "objectPro", "uiAsset", "uiElement", "imageProFlash", "vfx"]);
 var GridConfidenceSchema = import_zod.z.enum(["low", "medium", "high"]);
 var RevisionModeSchema = import_zod.z.enum([
   "image-to-image",
@@ -365,6 +388,7 @@ function candidateCount(size) {
   return 1;
 }
 function generationCost(width, height, generator = "map") {
+  if (generator === "vfx") return 0;
   if (generator === "map" || generator === "pixflux") return 1;
   if (generator === "imagePro") return proTierCost(width, height);
   const px = width * height;
@@ -549,6 +573,29 @@ var MapSceneSchema = import_zod.z.object({
   image: import_zod.z.string().min(1),
   placement: MapScenePlacementSchema.default({ oval: 0.3 })
 }).strict();
+var VfxPartSchema = import_zod.z.object({ name: import_zod.z.string().min(1) }).catchall(import_zod.z.unknown());
+var AssetVfxSchema = import_zod.z.object({
+  preset: import_zod.z.string().min(1).optional(),
+  recipe: import_zod.z.string().min(1).optional(),
+  parts: import_zod.z.array(VfxPartSchema).optional(),
+  sprite: import_zod.z.string().min(1).optional(),
+  fps: import_zod.z.number().int().min(1).max(60).optional(),
+  name: import_zod.z.string().min(1).optional()
+}).strict().superRefine((vfx, context) => {
+  if (vfx.preset && vfx.recipe) {
+    context.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: "start a vfx from a preset or a recipe, not both", path: ["recipe"] });
+  }
+  if (!vfx.preset && !vfx.recipe && !vfx.parts?.length) {
+    context.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: "a vfx needs a preset, a recipe, or at least one part", path: ["preset"] });
+  }
+  if (vfx.sprite && /^(https?|data):/i.test(vfx.sprite)) {
+    context.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "a vfx sprite is a manifest-relative image or a character:/object:/gallery: reference; a URL has no content to track",
+      path: ["sprite"]
+    });
+  }
+});
 var CharacterOutfitSchema = import_zod.z.object({
   /** The loop (a character animation asset) to re-clothe, in the same style. */
   of: import_zod.z.string().min(1),
@@ -1182,7 +1229,7 @@ var StyleSchema = StyleObjectSchema.refine((s) => !(s.tileFeature && s.styleImag
   message: "tileFeature and styleImages cannot be combined; a connectable set derives its own tile geometry, so remove one or the other",
   path: ["tileFeature"]
 }).superRefine((style, ctx) => {
-  if (style.quality && (style.generator === "tiles" || style.generator === "terrain" || style.generator === "animation")) {
+  if (style.quality && (style.generator === "tiles" || style.generator === "terrain" || style.generator === "animation" || style.generator === "vfx")) {
     ctx.addIssue({
       code: import_zod.z.ZodIssueCode.custom,
       message: "quality profiles currently support single-image generators only",
@@ -1312,6 +1359,8 @@ var AssetSchema = import_zod.z.object({
   outfit: CharacterOutfitSchema.optional(),
   /** `map` styles only: draw this object in the style of a scene image. See `MapSceneSchema`. */
   scene: MapSceneSchema.optional(),
+  /** `vfx` styles only: the effect to render. See `AssetVfxSchema`. */
+  vfx: AssetVfxSchema.optional(),
   /** `character` styles, `standard` humanoid bases: this character's proportions, over the style's. */
   proportions: CharacterProportionsSchema.optional(),
   /**
@@ -1388,7 +1437,7 @@ var AssetSchema = import_zod.z.object({
       path: ["revision"]
     });
   }
-  const shapes = [asset.revision && "revision", asset.state && "state", asset.animation && "animation", asset.mirror && "mirror", asset.batch && "batch", asset.portrait && "portrait", asset.outfit && "outfit", asset.scene && "scene"].filter(Boolean);
+  const shapes = [asset.revision && "revision", asset.state && "state", asset.animation && "animation", asset.mirror && "mirror", asset.batch && "batch", asset.portrait && "portrait", asset.outfit && "outfit", asset.scene && "scene", asset.vfx && "vfx"].filter(Boolean);
   if (shapes.length > 1) {
     context.addIssue({
       code: import_zod.z.ZodIssueCode.custom,
@@ -1403,7 +1452,7 @@ var AssetSchema = import_zod.z.object({
       path: ["mirror"]
     });
   }
-  if (asset.prompt === void 0 && !asset.mirror && !asset.portrait && !asset.outfit && !asset.animation?.template) {
+  if (asset.prompt === void 0 && !asset.mirror && !asset.portrait && !asset.outfit && !asset.animation?.template && !asset.vfx) {
     context.addIssue({
       code: import_zod.z.ZodIssueCode.custom,
       message: "Required",
@@ -2163,9 +2212,9 @@ var PixelLabClient = class {
   apiKey;
   http;
   /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
-  async request(path38, init) {
+  async request(path39, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    const res = await this.http(`${BASE}${path38}`, {
+    const res = await this.http(`${BASE}${path39}`, {
       ...init,
       headers: {
         Authorization: auth,
@@ -2175,13 +2224,13 @@ var PixelLabClient = class {
     });
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path38} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path39} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path38} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path39} returned invalid JSON`);
     }
   }
   async balance() {
@@ -2586,10 +2635,10 @@ var PixelLabClient = class {
     const palette = args.paletteSwatchBase64 ? { color_image: { type: "base64", base64: args.paletteSwatchBase64, format: "png" }, force_colors: true } : {};
     const encode = (image) => ({ type: "base64", base64: image.base64, format: image.format });
     const south = args.reference?.south;
-    let path38;
+    let path39;
     let body;
     if (args.mode === "v3") {
-      path38 = "/create-character-v3";
+      path39 = "/create-character-v3";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2603,7 +2652,7 @@ var PixelLabClient = class {
         ...args.enhancePrompt ? { enhance_prompt: true } : {}
       };
     } else if (args.mode === "pro-flash") {
-      path38 = "/create-character-pro-flash";
+      path39 = "/create-character-pro-flash";
       const traits = args.styleTraits;
       body = {
         description: args.description,
@@ -2627,7 +2676,7 @@ var PixelLabClient = class {
         } : {}
       };
     } else if (args.mode === "pro") {
-      path38 = "/create-character-pro";
+      path39 = "/create-character-pro";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2641,7 +2690,7 @@ var PixelLabClient = class {
         ...!south && args.styleCharacterId ? { style_character_id: args.styleCharacterId } : {}
       };
     } else {
-      path38 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
+      path39 = args.directions === 4 ? "/create-character-with-4-directions" : "/create-character-with-8-directions";
       body = {
         description: args.description,
         image_size: imageSize,
@@ -2658,8 +2707,8 @@ var PixelLabClient = class {
         ...palette
       };
     }
-    const raw = await this.request(path38, { method: "POST", body: JSON.stringify(body) });
-    return validateResponse(CharacterSubmitSchema, raw, path38.slice(1));
+    const raw = await this.request(path39, { method: "POST", body: JSON.stringify(body) });
+    return validateResponse(CharacterSubmitSchema, raw, path39.slice(1));
   }
   /** A text edit of an existing character, applied to every direction and stored as a sibling. */
   async createCharacterState(args) {
@@ -2959,8 +3008,8 @@ var PixelLabClient = class {
   /**
    * `/image-to-pixelart-pro-flash`: a photo, painting, or render in, pixel
    * art out, with no size to pass: PixelLab detects the native pixel scale
-   * and picks the output size (a 256x256 render came back 108x109, on a
-   * transparent background). A flat 6 generations, billed exactly that live
+   * and picks the output size (a 256x256 render came back 108x109). The
+   * result is opaque, on a near-white background. A flat 6 generations, billed exactly that live
    * in October 2026. Sources over 2048px on the longer side are scaled down
    * upstream. The finished job carries the image at `last_response.images[0]`.
    */
@@ -3884,10 +3933,10 @@ function imageMetadata(buf) {
 }
 
 // src/providers/pixellab.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_node_crypto2 = require("crypto");
 var import_node_os = __toESM(require("os"), 1);
-var import_node_path = __toESM(require("path"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 
 // src/hash.ts
 var import_node_crypto = require("crypto");
@@ -3895,16 +3944,17 @@ var import_node_fs = require("fs");
 function sha256(data) {
   return (0, import_node_crypto.createHash)("sha256").update(data).digest("hex");
 }
-async function sha256File(path38) {
+async function sha256File(path39) {
   return new Promise((resolve, reject) => {
     const hash = (0, import_node_crypto.createHash)("sha256");
-    const stream = (0, import_node_fs.createReadStream)(path38);
+    const stream = (0, import_node_fs.createReadStream)(path39);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
   });
 }
 function specHash(spec, styleImageHashes, providerOptionIdentity = spec.providerOptions, providerInputIdentity = spec.providerInputs ?? {}) {
+  const effect = Boolean(spec.vfx);
   return sha256(
     JSON.stringify({
       // Preserve every existing PixelLab hash while making a provider switch
@@ -3913,15 +3963,15 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
       providerOptions: providerOptionIdentity && (typeof providerOptionIdentity !== "object" || Object.keys(providerOptionIdentity).length > 0) ? providerOptionIdentity : void 0,
       providerInputs: providerInputIdentity && (typeof providerInputIdentity !== "object" || Object.keys(providerInputIdentity).length > 0) ? providerInputIdentity : void 0,
       generator: spec.generator,
-      prompt: spec.prompt,
-      width: spec.width,
-      height: spec.height,
-      view: spec.view,
-      outline: spec.outline ?? null,
-      shading: spec.shading ?? null,
-      detail: spec.detail ?? null,
-      seed: spec.seed ?? null,
-      palette: spec.palette,
+      prompt: effect ? void 0 : spec.prompt,
+      width: effect ? void 0 : spec.width,
+      height: effect ? void 0 : spec.height,
+      view: effect ? void 0 : spec.view,
+      outline: effect ? void 0 : spec.outline ?? null,
+      shading: effect ? void 0 : spec.shading ?? null,
+      detail: effect ? void 0 : spec.detail ?? null,
+      seed: effect ? void 0 : spec.seed ?? null,
+      palette: effect ? void 0 : spec.palette,
       // `noBackground` only reaches the wire for pixflux and uiAsset; the
       // tile fields are undefined for every other generator. `tileSize` is
       // intentionally absent; width/height are derived from it, so it is
@@ -3996,6 +4046,15 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
         styleTraits: spec.objectPro.styleTraits,
         reference: spec.objectPro.reference?.sha256
       } : void 0,
+      // A recipe and a local sprite enter as their contents' hashes, never
+      // their paths; the My effects name is not identity.
+      vfx: spec.vfx ? {
+        preset: spec.vfx.preset,
+        recipe: spec.vfx.recipe?.sha256,
+        parts: spec.vfx.parts,
+        fps: spec.vfx.fps,
+        sprite: spec.vfx.sprite ? "reference" in spec.vfx.sprite ? spec.vfx.sprite.reference : spec.vfx.sprite.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.
       mirror: spec.mirror ? { of: spec.mirror.sourceAssetId } : void 0,
@@ -4033,6 +4092,337 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
   );
 }
 
+// src/pixellab-mcp.ts
+var PIXELLAB_MCP_URL = "https://api.pixellab.ai/mcp";
+var PROTOCOL_VERSION = "2025-06-18";
+function parseMcpBody(body) {
+  const trimmed = body.trim();
+  if (trimmed.startsWith("{")) return JSON.parse(trimmed);
+  let last;
+  for (const line of body.split(/\r?\n/)) {
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice(5).trim();
+    if (!payload) continue;
+    const message6 = JSON.parse(payload);
+    if ("id" in message6) last = message6;
+  }
+  if (!last) throw new Error(`PixelLab MCP reply had no JSON-RPC response: ${body.slice(0, 200)}`);
+  return last;
+}
+function isBusyReply(text) {
+  return /\bbusy\b.*\bretry\b/i.test(text);
+}
+var PixelLabMcpClient = class {
+  constructor(apiKey, opts = {}) {
+    this.apiKey = apiKey;
+    if (!apiKey) throw new Error("PIXELLAB_API_KEY is required");
+    this.url = opts.url ?? PIXELLAB_MCP_URL;
+    this.http = fetchWithRetry(opts.fetch, { timeoutMs: opts.timeoutMs ?? 18e4 });
+    this.busyRetries = opts.busyRetries ?? 4;
+    this.sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  }
+  apiKey;
+  http;
+  url;
+  busyRetries;
+  sleep;
+  nextId = 1;
+  /**
+   * Call one tool and return its text and images. A tool-level error
+   * (`isError`) throws with the tool's own message, after a few spaced
+   * retries when the tool only said it was busy.
+   */
+  async callTool(name, args) {
+    for (let attempt = 0; ; attempt++) {
+      const reply = await this.callOnce(name, args);
+      if (!reply.isError) return { text: reply.text, images: reply.images };
+      if (attempt < this.busyRetries && isBusyReply(reply.text)) {
+        await this.sleep(2e3 * 2 ** attempt);
+        continue;
+      }
+      throw new Error(`PixelLab ${name}: ${reply.text || "the tool reported an error"}`);
+    }
+  }
+  async callOnce(name, args) {
+    const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
+    const id = this.nextId++;
+    const res = await this.http(this.url, {
+      method: "POST",
+      headers: {
+        Authorization: auth,
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        "MCP-Protocol-Version": PROTOCOL_VERSION
+      },
+      body: JSON.stringify({ jsonrpc: "2.0", id, method: "tools/call", params: { name, arguments: args } })
+    });
+    const body = await res.text();
+    if (!res.ok) throw new PixelLabError(`MCP ${name} \u2192 ${res.status}`, res.status, body);
+    const message6 = parseMcpBody(body);
+    const error = message6.error;
+    if (error) throw new Error(`PixelLab MCP ${name} failed: ${error.message ?? JSON.stringify(error)}`);
+    const result = message6.result ?? {};
+    const text = (result.content ?? []).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+    const images = (result.content ?? []).filter((block) => block.type === "image" && typeof block.data === "string").map((block) => ({ mimeType: String(block.mimeType ?? "image/png"), data: block.data }));
+    return { text, images, isError: Boolean(result.isError) };
+  }
+};
+function mcpClientFromEnv() {
+  const key = process.env.PIXELLAB_API_KEY;
+  if (!key) {
+    throw new Error(
+      "PIXELLAB_API_KEY is not set.\nLooked in the environment, and in .env.local / .env beside the manifest and in the current directory."
+    );
+  }
+  return new PixelLabMcpClient(key);
+}
+
+// src/pixellab-vfx.ts
+var import_node_fs2 = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var VFX_TOOL = "vfx_workbench";
+var UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+function parseVfxStep(text) {
+  const match = new RegExp(`effect step: (${UUID})`).exec(text);
+  if (!match) throw new Error(`PixelLab vfx_workbench returned no step id:
+${text.slice(0, 600)}`);
+  return match[1];
+}
+function parseVfxRecipe(text) {
+  const lines = text.split(/\r?\n/);
+  const at = lines.findIndex((line) => line.trim() === "working recipe:");
+  const json = at >= 0 ? lines[at + 1]?.trim() : void 0;
+  if (!json?.startsWith("{")) return null;
+  return JSON.parse(json);
+}
+function parseVfxExport(text) {
+  const effectId = new RegExp(`effect id (${UUID})`).exec(text)?.[1];
+  const download = /download (https:\/\/\S+\/): (.+)$/m.exec(text);
+  const size = /(\d+)x(\d+), (\d+) frames @ ([\d.]+) fps, ([^;\n]+)/.exec(text);
+  if (!effectId || !download || !size) {
+    throw new Error(`PixelLab vfx_workbench export reply was not understood:
+${text.slice(0, 600)}`);
+  }
+  const anchor = /anchor[^\n]*? at (-?\d+),\s*(-?\d+)/.exec(text);
+  return {
+    effectId,
+    editUrl: /(https:\/\/pixellab\.ai\/create-vfx\?effect=[0-9a-f-]+)/.exec(text)?.[1] ?? null,
+    width: Number(size[1]),
+    height: Number(size[2]),
+    frames: Number(size[3]),
+    fps: Number(size[4]),
+    loop: !/plays once/.test(size[5]),
+    anchor: anchor ? { x: Number(anchor[1]), y: Number(anchor[2]) } : null,
+    downloadBase: download[1],
+    files: download[2].split(",").map((file) => file.trim()).filter(Boolean),
+    imageId: new RegExp(`image id: (${UUID})`).exec(text)?.[1] ?? null
+  };
+}
+async function describeVfx(client2, topic) {
+  return (await client2.callTool(VFX_TOOL, { argv: ["describe", topic] })).text;
+}
+function vfxOutputPaths(out) {
+  const base = import_node_path.default.resolve(out.replace(/\.(png|gif|json|zip)$/i, "").replace(/\.vfx$/i, ""));
+  return {
+    sheet: `${base}.png`,
+    gif: `${base}.gif`,
+    atlas: `${base}.json`,
+    provenance: `${base}.vfx.json`,
+    gamePack: `${base}-game.zip`
+  };
+}
+function isVfxReference(sprite) {
+  return /^(character|object|gallery):/.test(sprite) || /^(https?|data):/.test(sprite);
+}
+async function resolveVfxSprite(sprite) {
+  if (isVfxReference(sprite)) return sprite;
+  const bytes = await (0, import_promises.readFile)(sprite);
+  const metadata = imageMetadata(bytes);
+  if (!metadata) throw new Error(`${sprite} is not a readable PNG or JPEG`);
+  return `data:image/${metadata.format};base64,${bytes.toString("base64")}`;
+}
+async function readVfxRecipe(file) {
+  const parsed = JSON.parse(await (0, import_promises.readFile)(file, "utf8"));
+  const record = parsed.tool === VFX_TOOL && parsed.recipe && typeof parsed.recipe === "object";
+  const recipe = record ? parsed.recipe : parsed;
+  if (!Array.isArray(recipe.layers)) throw new Error(`${file} is not a VFX recipe: it has no "layers" list`);
+  const recorded = record ? parsed.source?.sprite : void 0;
+  if (typeof recorded !== "string") return { recipe };
+  const sprite = isVfxReference(recorded) ? recorded : import_node_path.default.resolve(import_node_path.default.dirname(import_node_path.default.resolve(file)), recorded);
+  return { recipe, sprite };
+}
+async function defaultDownload(url) {
+  const http = fetchWithRetry();
+  const res = await http(url);
+  if (!res.ok) throw new Error(`download ${url} \u2192 ${res.status}`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  if (buf.length > MAX_DOWNLOAD_BYTES) throw new Error(`download ${url} exceeds the ${MAX_DOWNLOAD_BYTES}-byte safety limit`);
+  return buf;
+}
+function localPathFor(file, paths) {
+  if (/-game\.zip$/i.test(file)) return paths.gamePack;
+  if (/\.gif$/i.test(file)) return paths.gif;
+  if (/\.json$/i.test(file)) return paths.atlas;
+  if (/\.png$/i.test(file)) return paths.sheet;
+  return null;
+}
+async function runVfxWorkbench(client2, opts) {
+  const starts = [opts.preset, opts.recipe, opts.effect].filter((value) => value !== void 0).length;
+  if (starts > 1) throw new Error("Start a VFX from one of a preset, a recipe, or a saved effect, not several");
+  if (starts === 0 && !opts.parts?.length) {
+    throw new Error("A VFX needs something to start from: a preset, a recipe, a saved effect, or at least one part");
+  }
+  const progress = opts.onProgress ?? (() => {
+  });
+  const call = async (argv) => (await client2.callTool(VFX_TOOL, { argv, ...opts.notes ? { notes: opts.notes } : {} })).text;
+  const startArgv = ["start"];
+  if (opts.sprite) startArgv.push("--sprite", opts.sprite);
+  if (opts.preset) startArgv.push("--preset", opts.preset);
+  if (opts.effect) startArgv.push("--effect", opts.effect);
+  progress(opts.preset ? `starting from preset ${opts.preset}` : opts.effect ? `starting from saved effect ${opts.effect}` : "starting");
+  const started = await call(startArgv);
+  let step = parseVfxStep(started);
+  const savedName = opts.effect ? parseVfxRecipe(started)?.name : opts.recipe?.name;
+  const name = opts.name ?? (typeof savedName === "string" ? savedName : void 0) ?? opts.defaultName;
+  if (opts.recipe) {
+    progress("rendering the recipe");
+    step = parseVfxStep(await call([step, "render", JSON.stringify({ recipe: opts.recipe })]));
+  }
+  if (opts.parts?.length) {
+    progress(`adding ${opts.parts.map((part) => part.name).join(", ")}`);
+    step = parseVfxStep(await call([step, "add_part", JSON.stringify({ parts: opts.parts })]));
+  }
+  if (opts.fps !== void 0) {
+    progress(`setting ${opts.fps} fps`);
+    step = parseVfxStep(await call([step, "render", JSON.stringify({ patch: [{ op: "set", path: "fps", value: opts.fps }] })]));
+  }
+  const exportArgv = [step, "export", "--name", name];
+  if (opts.replace) exportArgv.push("--replace", opts.replace);
+  if (opts.gamePack) exportArgv.push("--game-pack");
+  progress(opts.gamePack ? "exporting with a game pack" : "exporting");
+  const exported = parseVfxExport(await call(exportArgv));
+  await opts.onExported?.(exported, name);
+  progress("reading the saved recipe");
+  const recipe = parseVfxRecipe(await call(["start", "--effect", exported.effectId]));
+  return { exported, recipe, name };
+}
+async function readSavedVfxRecipe(client2, effectId) {
+  try {
+    return parseVfxRecipe((await client2.callTool(VFX_TOOL, { argv: ["start", "--effect", effectId] })).text);
+  } catch (error) {
+    if (error instanceof Error && /no saved effect/i.test(error.message)) return null;
+    throw error;
+  }
+}
+function vfxRecipeSha256(recipe) {
+  const { name: _name, notes: _notes, ...rest } = recipe;
+  return sha256(JSON.stringify(rest));
+}
+function sliceVfxSheet(sheet, facts, atlas) {
+  const image = decodePng(sheet);
+  const listed = atlas?.frames;
+  const rects = Array.isArray(listed) && listed.length === facts.frames ? listed.map((entry) => entry.frame) : Array.from({ length: facts.frames }, (_, index) => {
+    const columns = Math.max(1, Math.floor(image.width / facts.width));
+    return { x: index % columns * facts.width, y: Math.floor(index / columns) * facts.height, w: facts.width, h: facts.height };
+  });
+  return rects.map((rect, index) => {
+    if (rect.x < 0 || rect.y < 0 || rect.x + rect.w > image.width || rect.y + rect.h > image.height) {
+      throw new Error(
+        `VFX frame ${index + 1} (${rect.w}x${rect.h} at ${rect.x},${rect.y}) falls outside the ${image.width}x${image.height} sheet`
+      );
+    }
+    const out = Buffer.alloc(rect.w * rect.h * 4);
+    for (let y = 0; y < rect.h; y++) {
+      const from = ((rect.y + y) * image.width + rect.x) * 4;
+      image.pixels.copy(out, y * rect.w * 4, from, from + rect.w * 4);
+    }
+    return encodeRgbaPng(rect.w, rect.h, out);
+  });
+}
+async function makeVfx(client2, opts) {
+  const starts = [opts.preset, opts.recipe, opts.effect].filter((value) => value !== void 0).length;
+  if (starts > 1) throw new Error("Start a VFX from one of a preset, a recipe, or a saved effect, not several");
+  if (starts === 0 && !opts.parts?.length) {
+    throw new Error("A VFX needs something to start from: a preset, a recipe, a saved effect, or at least one part");
+  }
+  const paths = vfxOutputPaths(opts.out);
+  const wanted = [paths.sheet, paths.gif, paths.atlas, paths.provenance, ...opts.gamePack ? [paths.gamePack] : []];
+  if (!opts.force) {
+    for (const file of wanted) {
+      if ((0, import_node_fs2.existsSync)(file)) throw new Error(`${file} already exists; pass --force to replace it`);
+    }
+  }
+  const progress = opts.onProgress ?? (() => {
+  });
+  const { exported, recipe, name } = await runVfxWorkbench(client2, {
+    preset: opts.preset,
+    recipe: opts.recipe,
+    effect: opts.effect,
+    parts: opts.parts,
+    sprite: opts.sprite ? await resolveVfxSprite(opts.sprite) : void 0,
+    fps: opts.fps,
+    name: opts.name,
+    defaultName: opts.preset ?? import_node_path.default.basename(paths.sheet, ".png"),
+    replace: opts.replace ?? opts.effect,
+    gamePack: opts.gamePack,
+    notes: "pixelkiln vfx",
+    onProgress: progress
+  });
+  const download = opts.download ?? defaultDownload;
+  const written = { sheet: paths.sheet, gif: paths.gif, atlas: paths.atlas, provenance: paths.provenance };
+  await (0, import_promises.mkdir)(import_node_path.default.dirname(paths.sheet), { recursive: true });
+  for (const file of exported.files) {
+    const target = localPathFor(file, paths);
+    if (!target) continue;
+    let bytes = await download(`${exported.downloadBase}${encodeURIComponent(file)}`);
+    if (target === paths.atlas) {
+      const atlas = JSON.parse(bytes.toString("utf8"));
+      if (atlas.meta) atlas.meta.image = import_node_path.default.basename(paths.sheet);
+      bytes = Buffer.from(`${JSON.stringify(atlas, null, 2)}
+`);
+    }
+    await (0, import_promises.writeFile)(target, bytes);
+    if (target === paths.gamePack) written.gamePack = target;
+  }
+  for (const file of [paths.sheet, paths.gif, paths.atlas]) {
+    if (!(0, import_node_fs2.existsSync)(file)) throw new Error(`PixelLab's export listed no file for ${import_node_path.default.basename(file)}: ${exported.files.join(", ")}`);
+  }
+  const spriteRecord = !opts.sprite || /^data:/.test(opts.sprite) ? void 0 : isVfxReference(opts.sprite) ? opts.sprite : import_node_path.default.relative(import_node_path.default.dirname(paths.provenance), import_node_path.default.resolve(opts.sprite)).split(import_node_path.default.sep).join("/");
+  const provenance = {
+    version: 1,
+    provider: "pixellab",
+    tool: VFX_TOOL,
+    name,
+    effectId: exported.effectId,
+    editUrl: exported.editUrl,
+    source: {
+      ...opts.preset ? { preset: opts.preset } : {},
+      ...opts.effect ? { effect: opts.effect } : {},
+      ...opts.recipe ? { recipeFile: true } : {},
+      ...opts.parts?.length ? { parts: opts.parts } : {},
+      ...spriteRecord ? { sprite: spriteRecord } : {}
+    },
+    width: exported.width,
+    height: exported.height,
+    frames: exported.frames,
+    fps: exported.fps,
+    loop: exported.loop,
+    anchor: exported.anchor,
+    files: {
+      sheet: import_node_path.default.basename(paths.sheet),
+      gif: import_node_path.default.basename(paths.gif),
+      atlas: import_node_path.default.basename(paths.atlas),
+      ...written.gamePack ? { gamePack: import_node_path.default.basename(written.gamePack) } : {}
+    },
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    recipe
+  };
+  await (0, import_promises.writeFile)(paths.provenance, `${JSON.stringify(provenance, null, 2)}
+`);
+  return { ...exported, paths: written, recipe };
+}
+
 // src/providers/pixellab.ts
 function pixelLabObjectUrl(generator, objectId) {
   if (!objectId) return null;
@@ -4047,6 +4437,7 @@ function pixelLabObjectUrl(generator, objectId) {
     const characterId = objectId.split("#")[0];
     return characterId ? `https://www.pixellab.ai/create-character/${encodeURIComponent(characterId)}` : null;
   }
+  if (generator === "vfx") return `https://pixellab.ai/create-vfx?effect=${encodeURIComponent(objectId)}`;
   return null;
 }
 function billedFromUsage(usage) {
@@ -4163,13 +4554,20 @@ function decodeObjectAnimationJob(jobId) {
   return null;
 }
 var PixelLabProvider = class _PixelLabProvider {
-  constructor(client2) {
+  /**
+   * `mcp` reaches the tools PixelLab offers only over MCP (the VFX
+   * workbench). Offline and download-only providers have none, and a `vfx`
+   * submission through one says so.
+   */
+  constructor(client2, mcp) {
     this.client = client2;
+    this.mcp = mcp;
   }
   client;
+  mcp;
   id = "pixellab";
   static fromEnv() {
-    return new _PixelLabProvider(clientFromEnv());
+    return new _PixelLabProvider(clientFromEnv(), mcpClientFromEnv());
   }
   /** Public storage URLs and the local content cache do not require API auth. */
   static forDownloads() {
@@ -4180,7 +4578,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" || generator === "objectPro" || generator === "uiAsset" || generator === "uiElement" || generator === "imageProFlash";
+    return generator === "1dir" || generator === "map" || generator === "pixflux" || generator === "tiles" || generator === "terrain" || generator === "imagePro" || generator === "character" || generator === "isometricTile" || generator === "objectPro" || generator === "uiAsset" || generator === "uiElement" || generator === "imageProFlash" || generator === "vfx";
   }
   /** `/map-objects` style matching: `background_image` plus `inpainting`. */
   supportsMapScene = true;
@@ -4222,11 +4620,12 @@ var PixelLabProvider = class _PixelLabProvider {
    * is a file read.
    */
   static cacheDir(namespace = "pixflux") {
-    const dir = import_node_path.default.join(import_node_os.default.tmpdir(), `pixelkiln-${namespace}`);
-    (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+    const dir = import_node_path2.default.join(import_node_os.default.tmpdir(), `pixelkiln-${namespace}`);
+    (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
     return dir;
   }
   estimate(spec) {
+    if (spec.vfx) return { unit: "generations", amount: 0, candidates: 1 };
     if (spec.batch?.role === "member") {
       return { unit: "generations", amount: 0, candidates: 1 };
     }
@@ -4284,6 +4683,9 @@ var PixelLabProvider = class _PixelLabProvider {
     };
   }
   validate(spec, styleImages) {
+    if (spec.generator === "vfx" && styleImages.length) {
+      throw new Error("PixelLab vfx takes no style images; an effect's look comes from its preset, parts, or recipe");
+    }
     const members = spec.revision?.sourceMembers;
     if (spec.revision && members && !MEMBER_SET_REVISION_MODES.includes(spec.revision.mode)) {
       throw new Error(
@@ -4568,7 +4970,7 @@ var PixelLabProvider = class _PixelLabProvider {
         }
       }
       if (endFrame) {
-        const start = startFrame ?? (character.parentFile && (0, import_node_fs2.existsSync)(character.parentFile) ? imageMetadata((0, import_node_fs2.readFileSync)(character.parentFile)) : null);
+        const start = startFrame ?? (character.parentFile && (0, import_node_fs3.existsSync)(character.parentFile) ? imageMetadata((0, import_node_fs3.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`
@@ -4726,7 +5128,7 @@ var PixelLabProvider = class _PixelLabProvider {
         }
       }
       if (endFrame) {
-        const start = startFrame ?? (object.parentFile && (0, import_node_fs2.existsSync)(object.parentFile) ? imageMetadata((0, import_node_fs2.readFileSync)(object.parentFile)) : null);
+        const start = startFrame ?? (object.parentFile && (0, import_node_fs3.existsSync)(object.parentFile) ? imageMetadata((0, import_node_fs3.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`
@@ -4781,13 +5183,13 @@ var PixelLabProvider = class _PixelLabProvider {
         );
       }
       const frames = parentOutputs.slice(0, 16).map((output) => {
-        const bytes = (0, import_node_fs2.readFileSync)(output.path);
+        const bytes = (0, import_node_fs3.readFileSync)(output.path);
         const dims = imageMetadata(bytes);
         if (!dims) throw new Error(`${spec.styleId}/${spec.assetId}: outfit source frame is not a readable PNG: ${output.path}`);
         return { base64: bytes.toString("base64"), format: "png", width: dims.width, height: dims.height };
       });
       const outfit = character.outfit;
-      const referenceBytes = (0, import_node_fs2.readFileSync)(outfit.reference.path);
+      const referenceBytes = (0, import_node_fs3.readFileSync)(outfit.reference.path);
       if (sha256(referenceBytes) !== outfit.reference.sha256) {
         throw new Error(`${spec.styleId}/${spec.assetId}: outfit reference changed after the manifest was resolved: ${outfit.reference.path}`);
       }
@@ -4830,7 +5232,7 @@ var PixelLabProvider = class _PixelLabProvider {
     }
     if (character.kind === "portrait") {
       const parentFile = character.parentFile;
-      const bytes = (0, import_node_fs2.readFileSync)(parentFile);
+      const bytes = (0, import_node_fs3.readFileSync)(parentFile);
       if (character.parentSha256 && sha256(bytes) !== character.parentSha256) {
         throw new Error(`${spec.styleId}/${spec.assetId}: portrait source changed after the manifest was resolved: ${parentFile}`);
       }
@@ -5036,8 +5438,8 @@ var PixelLabProvider = class _PixelLabProvider {
     const sources = images.map((image, index) => {
       if (!image.base64) throw new Error(`outfit transfer frame ${index} has no image data`);
       const role = meta?.frameRoles?.[index] ?? void 0;
-      const file = import_node_path.default.join(dir, `${jobId}-${index}.png`);
-      (0, import_node_fs2.writeFileSync)(file, Buffer.from(image.base64, "base64"));
+      const file = import_node_path2.default.join(dir, `${jobId}-${index}.png`);
+      (0, import_node_fs3.writeFileSync)(file, Buffer.from(image.base64, "base64"));
       return { url: `file://${file}`, ...role ? { role } : {} };
     });
     return {
@@ -5188,6 +5590,7 @@ var PixelLabProvider = class _PixelLabProvider {
   async submit(spec, styleImages, context) {
     this.validate(spec, styleImages);
     if (spec.revision) return this.submitRevision(spec);
+    if (spec.vfx) return this.submitVfx(spec, context);
     if (spec.generator === "character") return this.submitCharacter(spec, styleImages, context);
     if (spec.generator === "objectPro") return this.submitObjectPro(spec, styleImages, context);
     if (spec.generator === "uiAsset") {
@@ -5241,7 +5644,7 @@ var PixelLabProvider = class _PixelLabProvider {
         seed: spec.seed
       });
       const jobId = (0, import_node_crypto2.randomUUID)();
-      (0, import_node_fs2.writeFileSync)(import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), png);
+      (0, import_node_fs3.writeFileSync)(import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), png);
       return { jobId };
     }
     if (spec.generator === "tiles") {
@@ -5361,7 +5764,7 @@ var PixelLabProvider = class _PixelLabProvider {
     }
     const sourceFiles = revision.sourceMembers ?? [{ file: revision.sourceFile, sha256: revision.sourceSha256, format: revision.sourceFormat }];
     const images = sourceFiles.map((member) => {
-      const bytes = (0, import_node_fs2.readFileSync)(member.file);
+      const bytes = (0, import_node_fs3.readFileSync)(member.file);
       if (sha256(bytes) !== member.sha256) {
         throw new Error(`${spec.styleId}/${spec.assetId}: revision source changed after the manifest was resolved`);
       }
@@ -5376,7 +5779,7 @@ var PixelLabProvider = class _PixelLabProvider {
         if (!revision.maskFile || !revision.maskSha256 || !revision.maskFormat) {
           throw new Error(`${spec.styleId}/${spec.assetId}: revision mask is not ready`);
         }
-        const maskBytes = (0, import_node_fs2.readFileSync)(revision.maskFile);
+        const maskBytes = (0, import_node_fs3.readFileSync)(revision.maskFile);
         if (sha256(maskBytes) !== revision.maskSha256) {
           throw new Error(`${spec.styleId}/${spec.assetId}: revision mask changed after the manifest was resolved`);
         }
@@ -5401,7 +5804,7 @@ var PixelLabProvider = class _PixelLabProvider {
       if (!revision.maskFile || !revision.maskSha256 || !revision.maskFormat) {
         throw new Error(`${spec.styleId}/${spec.assetId}: revision mask is not ready`);
       }
-      const maskBytes = (0, import_node_fs2.readFileSync)(revision.maskFile);
+      const maskBytes = (0, import_node_fs3.readFileSync)(revision.maskFile);
       if (sha256(maskBytes) !== revision.maskSha256) {
         throw new Error(`${spec.styleId}/${spec.assetId}: revision mask changed after the manifest was resolved`);
       }
@@ -5422,7 +5825,7 @@ var PixelLabProvider = class _PixelLabProvider {
         if (!revision.paletteImageSha256 || !revision.paletteImageFormat) {
           throw new Error(`${spec.styleId}/${spec.assetId}: revision palette image is not ready`);
         }
-        const paletteBytes = (0, import_node_fs2.readFileSync)(revision.paletteImageFile);
+        const paletteBytes = (0, import_node_fs3.readFileSync)(revision.paletteImageFile);
         if (sha256(paletteBytes) !== revision.paletteImageSha256) {
           throw new Error(`${spec.styleId}/${spec.assetId}: revision palette image changed after the manifest was resolved`);
         }
@@ -5513,7 +5916,7 @@ var PixelLabProvider = class _PixelLabProvider {
       if (!revision.keypointsFile || !revision.keypointsSha256 || !revision.skeleton) {
         throw new Error(`${spec.styleId}/${spec.assetId}: revision keypoints are not ready`);
       }
-      const keypointsBytes = (0, import_node_fs2.readFileSync)(revision.keypointsFile);
+      const keypointsBytes = (0, import_node_fs3.readFileSync)(revision.keypointsFile);
       if (sha256(keypointsBytes) !== revision.keypointsSha256) {
         throw new Error(`${spec.styleId}/${spec.assetId}: revision keypoints changed after the manifest was resolved`);
       }
@@ -5555,7 +5958,7 @@ var PixelLabProvider = class _PixelLabProvider {
     if (!revision.lastFrameSha256 || !revision.lastFrameFormat) {
       throw new Error(`${spec.styleId}/${spec.assetId}: revision last frame is not ready`);
     }
-    const bytes = (0, import_node_fs2.readFileSync)(revision.lastFrameFile);
+    const bytes = (0, import_node_fs3.readFileSync)(revision.lastFrameFile);
     if (sha256(bytes) !== revision.lastFrameSha256) {
       throw new Error(`${spec.styleId}/${spec.assetId}: revision last frame changed after the manifest was resolved`);
     }
@@ -5570,11 +5973,11 @@ var PixelLabProvider = class _PixelLabProvider {
   cacheCleanupResult(pngs, usage, roles, fps) {
     const jobId = (0, import_node_crypto2.randomUUID)();
     if (!roles) {
-      (0, import_node_fs2.writeFileSync)(import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), pngs[0]);
+      (0, import_node_fs3.writeFileSync)(import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), pngs[0]);
       return { jobId, metadata: { revisionUsage: usage } };
     }
     for (const [index, png] of pngs.entries()) {
-      (0, import_node_fs2.writeFileSync)(import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`), png);
+      (0, import_node_fs3.writeFileSync)(import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`), png);
     }
     return { jobId, metadata: { revisionUsage: usage, revisionMembers: roles, ...fps != null ? { revisionFps: fps } : {} } };
   }
@@ -5602,10 +6005,11 @@ var PixelLabProvider = class _PixelLabProvider {
       return this.pollAnimateRevision(jobId, context);
     }
     if (context?.spec?.revision) return this.pollRevision(jobId);
+    if (generator === "vfx") return this.pollVfx(jobId, context);
     if (generator === "imageProFlash") return this.pollRevision(jobId);
     if (generator === "pixflux") {
-      const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
-      if ((0, import_node_fs2.existsSync)(file)) {
+      const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+      if ((0, import_node_fs3.existsSync)(file)) {
         const sourceUrl = `file://${file}`;
         return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }] };
       }
@@ -5648,6 +6052,120 @@ var PixelLabProvider = class _PixelLabProvider {
    * background job to ask afterwards the way `billedForJob` does for async
    * work.
    */
+  /**
+   * Render a `vfx` asset with the VFX workbench, which is synchronous and
+   * free. The frames are cut from the exported sheet and parked in the
+   * cache like pixflux's bytes; the export's download folder is recorded so
+   * `poll` can cut them again if the cache is cleared.
+   *
+   * A regeneration exports over the effect this asset rendered last time, so
+   * My effects keeps one entry per asset, unless that effect has changed on
+   * pixellab.ai since (someone moved its sliders) or is gone. Then a new
+   * effect is saved and the edited one is left alone.
+   */
+  async submitVfx(spec, context) {
+    const vfx = spec.vfx;
+    if (!this.mcp) throw new Error("PixelLab vfx renders over PixelLab's MCP server, which this provider was built without");
+    let sprite;
+    if (vfx.sprite && "reference" in vfx.sprite) {
+      sprite = vfx.sprite.reference;
+    } else if (vfx.sprite) {
+      const { file } = vfx.sprite;
+      if (!(0, import_node_fs3.existsSync)(file)) throw new Error(`vfx sprite does not exist yet: ${file}`);
+      const bytes = (0, import_node_fs3.readFileSync)(file);
+      if (sha256(bytes) !== vfx.sprite.sha256) {
+        throw new Error(`vfx sprite changed after the manifest was resolved: ${file}; run the command again`);
+      }
+      const format = imageMetadata(bytes)?.format ?? "png";
+      sprite = `data:image/${format};base64,${bytes.toString("base64")}`;
+    }
+    const previous = context?.replacedMetadata?.vfx ?? context?.lastGenerationMetadata?.vfx;
+    let replace;
+    let newEffect;
+    if (previous?.effectId) {
+      const upstream = await readSavedVfxRecipe(this.mcp, previous.effectId);
+      if (!upstream) newEffect = `effect ${previous.effectId} is no longer in My effects`;
+      else if (!previous.recipe || vfxRecipeSha256(upstream) !== vfxRecipeSha256(previous.recipe)) {
+        newEffect = `effect ${previous.effectId} changed on pixellab.ai since it was rendered; it was kept`;
+      } else replace = previous.effectId;
+    }
+    const jobId = (0, import_node_crypto2.randomUUID)();
+    const facts = (exported2, name2) => ({
+      effectId: exported2.effectId,
+      editUrl: exported2.editUrl,
+      name: name2,
+      imageId: exported2.imageId,
+      width: exported2.width,
+      height: exported2.height,
+      frames: exported2.frames,
+      fps: exported2.fps,
+      loop: exported2.loop,
+      anchor: exported2.anchor,
+      downloadBase: exported2.downloadBase,
+      files: exported2.files,
+      replaced: replace ?? null,
+      ...newEffect ? { newEffect } : {}
+    });
+    const { exported, recipe, name } = await runVfxWorkbench(this.mcp, {
+      preset: vfx.preset,
+      recipe: vfx.recipe?.recipe,
+      parts: vfx.parts,
+      sprite,
+      fps: vfx.fps,
+      name: vfx.name,
+      defaultName: vfx.name,
+      replace,
+      notes: `pixelkiln ${spec.styleId}/${spec.assetId}`,
+      // The effect exists from here on; record it before anything else can fail.
+      onExported: (done, effectName) => context?.checkpoint({ jobId, complete: true, metadata: { vfx: facts(done, effectName) } })
+    });
+    await this.cacheVfxFrames(jobId, exported);
+    return { jobId, metadata: { vfx: { ...facts(exported, name), recipe } } };
+  }
+  /** Cut an export's sheet into frames, with a sidecar `poll` reads without any lock metadata. */
+  async cacheVfxFrames(jobId, exported) {
+    const sheetFile = exported.files.find((file) => /\.png$/i.test(file));
+    const atlasFile = exported.files.find((file) => /\.json$/i.test(file));
+    if (!sheetFile) throw new Error(`PixelLab's vfx export listed no spritesheet: ${exported.files.join(", ")}`);
+    const sheet = await this.client.download(`${exported.downloadBase}${encodeURIComponent(sheetFile)}`);
+    const atlas = atlasFile ? JSON.parse((await this.client.download(`${exported.downloadBase}${encodeURIComponent(atlasFile)}`)).toString("utf8")) : void 0;
+    const frames = sliceVfxSheet(sheet, exported, atlas);
+    const dir = _PixelLabProvider.cacheDir("vfx");
+    frames.forEach((frame, index) => (0, import_node_fs3.writeFileSync)(import_node_path2.default.join(dir, `${jobId}-${index}.png`), frame));
+    (0, import_node_fs3.writeFileSync)(
+      import_node_path2.default.join(dir, `${jobId}.json`),
+      JSON.stringify({ effectId: exported.effectId, count: frames.length, fps: exported.fps, loop: exported.loop })
+    );
+  }
+  async pollVfx(jobId, context) {
+    const dir = _PixelLabProvider.cacheDir("vfx");
+    const sidecar = import_node_path2.default.join(dir, `${jobId}.json`);
+    const cached = () => {
+      if (!(0, import_node_fs3.existsSync)(sidecar)) return null;
+      const facts2 = JSON.parse((0, import_node_fs3.readFileSync)(sidecar, "utf8"));
+      const files2 = Array.from({ length: facts2.count }, (_, index) => import_node_path2.default.join(dir, `${jobId}-${index}.png`));
+      return files2.every((file) => (0, import_node_fs3.existsSync)(file)) ? { facts: facts2, files: files2 } : null;
+    };
+    let found = cached();
+    const recorded = context?.metadata?.vfx;
+    if (!found && recorded?.downloadBase && Array.isArray(recorded.files)) {
+      await this.cacheVfxFrames(jobId, recorded);
+      found = cached();
+    }
+    if (!found) {
+      return { status: "failed", error: "vfx frames are no longer cached locally; re-run submit for this asset (free)" };
+    }
+    const { facts, files } = found;
+    const sources = files.length === 1 ? [{ url: `file://${files[0]}` }] : files.map((file, index) => ({ url: `file://${file}`, role: `frame-${String(index).padStart(2, "0")}` }));
+    return {
+      status: "ready",
+      objectId: facts.effectId,
+      sourceUrl: sources[0].url,
+      sources,
+      ...files.length > 1 ? { metadata: { frameSet: { fps: facts.fps, count: files.length, loop: facts.loop } } } : {},
+      billed: null
+    };
+  }
   async pollCachedRevision(jobId, context) {
     const usage = context?.metadata?.revisionUsage;
     const roles = context?.metadata?.revisionMembers;
@@ -5657,10 +6175,10 @@ var PixelLabProvider = class _PixelLabProvider {
     };
     if (Array.isArray(roles) && roles.length) {
       const sources = roles.map((role, index) => ({
-        url: `file://${import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`)}`,
+        url: `file://${import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`)}`,
         role: String(role)
       }));
-      if (sources.some((source) => !(0, import_node_fs2.existsSync)(source.url.slice("file://".length)))) return gone;
+      if (sources.some((source) => !(0, import_node_fs3.existsSync)(source.url.slice("file://".length)))) return gone;
       const fps = context?.metadata?.revisionFps;
       const frames = sources.every((source) => source.role.startsWith("frame-"));
       return {
@@ -5672,8 +6190,8 @@ var PixelLabProvider = class _PixelLabProvider {
         billed: billedFromUsage(usage)
       };
     }
-    const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
-    if (!(0, import_node_fs2.existsSync)(file)) return gone;
+    const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+    if (!(0, import_node_fs3.existsSync)(file)) return gone;
     const sourceUrl = `file://${file}`;
     return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }], billed: billedFromUsage(usage) };
   }
@@ -5729,8 +6247,8 @@ var PixelLabProvider = class _PixelLabProvider {
         }
         const base64 = extractBase64(item);
         if (base64) {
-          const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
-          (0, import_node_fs2.writeFileSync)(file, Buffer.from(base64, "base64"));
+          const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+          (0, import_node_fs3.writeFileSync)(file, Buffer.from(base64, "base64"));
           urls.push(`file://${file}`);
           continue;
         }
@@ -5780,8 +6298,8 @@ var PixelLabProvider = class _PixelLabProvider {
       const candidate = done[key];
       const base64 = extractBase64(candidate);
       if (base64) {
-        const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
-        (0, import_node_fs2.writeFileSync)(file, Buffer.from(base64, "base64"));
+        const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+        (0, import_node_fs3.writeFileSync)(file, Buffer.from(base64, "base64"));
         const sourceUrl = `file://${file}`;
         return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }], billed };
       }
@@ -5789,8 +6307,8 @@ var PixelLabProvider = class _PixelLabProvider {
     if (Array.isArray(done.images) && done.images.length) {
       const base64 = extractBase64(done.images[0]);
       if (base64) {
-        const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
-        (0, import_node_fs2.writeFileSync)(file, Buffer.from(base64, "base64"));
+        const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+        (0, import_node_fs3.writeFileSync)(file, Buffer.from(base64, "base64"));
         const sourceUrl = `file://${file}`;
         return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }], billed };
       }
@@ -5823,8 +6341,8 @@ var PixelLabProvider = class _PixelLabProvider {
       for (const [index, candidate] of done.images.entries()) {
         const base64 = extractBase64(candidate);
         if (!base64) continue;
-        const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
-        (0, import_node_fs2.writeFileSync)(file, Buffer.from(base64, "base64"));
+        const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+        (0, import_node_fs3.writeFileSync)(file, Buffer.from(base64, "base64"));
         urls.push(`file://${file}`);
       }
       if (urls.length) return { status: "review", candidateUrls: urls, billed };
@@ -5853,8 +6371,8 @@ var PixelLabProvider = class _PixelLabProvider {
     for (const [index, candidate] of images.entries()) {
       const base64 = extractBase64(candidate);
       if (!base64) continue;
-      const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
-      (0, import_node_fs2.writeFileSync)(file, Buffer.from(base64, "base64"));
+      const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+      (0, import_node_fs3.writeFileSync)(file, Buffer.from(base64, "base64"));
       urls.push(`file://${file}`);
     }
     if (urls.length === 1) return { status: "ready", objectId: jobId, sourceUrl: urls[0], sources: [{ url: urls[0] }], billed };
@@ -5951,8 +6469,8 @@ var PixelLabProvider = class _PixelLabProvider {
       for (const [index, tile] of tileset.tiles.entries()) {
         const slug2 = tile.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "tile";
         const role = `tile-${String(index).padStart(2, "0")}-${slug2}`;
-        const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${tilesetId}-${index}.png`);
-        (0, import_node_fs2.writeFileSync)(file, Buffer.from(tile.image.base64, "base64"));
+        const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${tilesetId}-${index}.png`);
+        (0, import_node_fs3.writeFileSync)(file, Buffer.from(tile.image.base64, "base64"));
         sources.push({ url: `file://${file}`, role });
         terrainTiles.push({ role, corners: tile.corners, pattern4x4: tile.pattern_4x4 });
       }
@@ -5981,8 +6499,8 @@ var PixelLabProvider = class _PixelLabProvider {
       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"));
+      const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${tileId}.png`);
+      (0, import_node_fs3.writeFileSync)(file, Buffer.from(image.base64, "base64"));
       return {
         status: "ready",
         objectId: tileId,
@@ -6025,8 +6543,8 @@ var PixelLabProvider = class _PixelLabProvider {
       return { objectId: `${jobId}#${index}`, sourceUrl: url };
     }
     if (generator === "imagePro" || generator === "uiElement") {
-      const file = import_node_path.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
-      if (!(0, import_node_fs2.existsSync)(file)) throw new Error(`${generator} job ${jobId} has no cached candidate at index ${index}`);
+      const file = import_node_path2.default.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+      if (!(0, import_node_fs3.existsSync)(file)) throw new Error(`${generator} job ${jobId} has no cached candidate at index ${index}`);
       return { objectId: `${jobId}#${index}`, sourceUrl: `file://${file}` };
     }
     const promoted = await this.client.selectFrames(jobId, [index], commonTag);
@@ -6038,7 +6556,7 @@ var PixelLabProvider = class _PixelLabProvider {
     return { objectId, sourceUrl: firstUrl(obj?.rotation_urls) ?? obj?.preview_url ?? null };
   }
   async download(url) {
-    if (url.startsWith("file://")) return (0, import_node_fs2.readFileSync)(url.slice("file://".length));
+    if (url.startsWith("file://")) return (0, import_node_fs3.readFileSync)(url.slice("file://".length));
     return this.client.download(url);
   }
   async balance() {
@@ -6160,7 +6678,7 @@ function extractBase64(value) {
 function readReference(spec, reference) {
   const images = {};
   for (const [direction, image] of Object.entries(reference)) {
-    const bytes = (0, import_node_fs2.readFileSync)(image.path);
+    const bytes = (0, import_node_fs3.readFileSync)(image.path);
     if (sha256(bytes) !== image.sha256) {
       throw new Error(`${spec.styleId}/${spec.assetId}: reference (${direction}) changed after the manifest was resolved: ${image.path}`);
     }
@@ -6177,7 +6695,7 @@ function requireStyleObjectId(spec, context) {
   return context.styleObjectId;
 }
 function readPose(spec, what, image) {
-  const bytes = (0, import_node_fs2.readFileSync)(image.path);
+  const bytes = (0, import_node_fs3.readFileSync)(image.path);
   if (sha256(bytes) !== image.sha256) {
     throw new Error(`${spec.styleId}/${spec.assetId}: ${what} changed after the manifest was resolved: ${image.path}`);
   }
@@ -6242,7 +6760,7 @@ function findObjectAnimation(object, name, direction, animationId) {
 function mapScenePayload(spec) {
   const scene = spec.scene;
   const read = (file, hash, label) => {
-    const bytes = (0, import_node_fs2.readFileSync)(file);
+    const bytes = (0, import_node_fs3.readFileSync)(file);
     if (!hash || sha256(bytes) !== hash) {
       throw new Error(`${spec.styleId}/${spec.assetId}: ${label} changed after the manifest was resolved`);
     }
@@ -6303,9 +6821,9 @@ var RetroDiffusionClient = class {
     if (!response.ok) throw new ProviderError("retrodiffusion", `Retro Diffusion download failed (${response.status})`, { status: response.status });
     return Buffer.from(await response.arrayBuffer());
   }
-  async call(path38, init = {}) {
+  async call(path39, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path38}`, {
+    const response = await this.request(`${this.baseUrl}${path39}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -6615,9 +7133,9 @@ function retroError(value) {
 
 // src/providers/scenario.ts
 var import_node_crypto3 = require("crypto");
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var DEFAULT_BASE_URL2 = "https://api.cloud.scenario.com/v1";
 var SOURCE_PROTOCOL2 = "scenario:";
 var SUBMIT_RETRIES = 8;
@@ -7000,7 +7518,7 @@ var ScenarioProvider = class _ScenarioProvider {
   }
 };
 function uploadCachePath() {
-  return process.env.SCENARIO_UPLOAD_CACHE ?? import_node_path2.default.join(import_node_os2.default.tmpdir(), "pixelkiln-scenario", "uploads.json");
+  return process.env.SCENARIO_UPLOAD_CACHE ?? import_node_path3.default.join(import_node_os2.default.tmpdir(), "pixelkiln-scenario", "uploads.json");
 }
 function uploadCacheKey(baseUrl, projectId, digest2) {
   return (0, import_node_crypto3.createHash)("sha256").update(`${baseUrl}
@@ -7009,7 +7527,7 @@ ${digest2}`).digest("hex");
 }
 function readUploadCache() {
   try {
-    const value = JSON.parse((0, import_node_fs3.readFileSync)(uploadCachePath(), "utf8"));
+    const value = JSON.parse((0, import_node_fs4.readFileSync)(uploadCachePath(), "utf8"));
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
   } catch {
     return {};
@@ -7018,10 +7536,10 @@ function readUploadCache() {
 function writeUploadCache(key, assetId) {
   try {
     const file = uploadCachePath();
-    (0, import_node_fs3.mkdirSync)(import_node_path2.default.dirname(file), { recursive: true });
+    (0, import_node_fs4.mkdirSync)(import_node_path3.default.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    (0, import_node_fs3.writeFileSync)(tmp, JSON.stringify({ ...readUploadCache(), [key]: assetId }));
-    (0, import_node_fs3.renameSync)(tmp, file);
+    (0, import_node_fs4.writeFileSync)(tmp, JSON.stringify({ ...readUploadCache(), [key]: assetId }));
+    (0, import_node_fs4.renameSync)(tmp, file);
   } catch {
   }
 }
@@ -7048,7 +7566,7 @@ function readRevisionSource(spec) {
   if (!revision.sourceFile || !revision.sourceSha256 || !revision.sourceFormat) {
     throw new Error(`${spec.styleId}/${spec.assetId}: revision source is not ready`);
   }
-  const bytes = (0, import_node_fs3.readFileSync)(revision.sourceFile);
+  const bytes = (0, import_node_fs4.readFileSync)(revision.sourceFile);
   if (sha256(bytes) !== revision.sourceSha256) {
     throw new Error(`${spec.styleId}/${spec.assetId}: revision source changed after the manifest was resolved`);
   }
@@ -7218,8 +7736,8 @@ function redactScenarioError(value, secrets) {
 
 // src/providers/comfyui.ts
 var import_node_crypto4 = require("crypto");
-var import_promises = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_promises2 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
 var DEFAULT_BASE_URL3 = "http://127.0.0.1:8188";
 var BUILTIN_BINDINGS = /* @__PURE__ */ new Set([
   "prompt",
@@ -7356,10 +7874,10 @@ var ComfyUIProvider = class _ComfyUIProvider {
   }
   async resolveOptions(value, context) {
     const options = parseOptions(value);
-    const workflowPath = import_node_path3.default.resolve(context.root, options.workflowFile);
+    const workflowPath = import_node_path4.default.resolve(context.root, options.workflowFile);
     let raw;
     try {
-      raw = await (0, import_promises.readFile)(workflowPath, "utf8");
+      raw = await (0, import_promises2.readFile)(workflowPath, "utf8");
     } catch (err) {
       throw new Error(
         `ComfyUI workflow for style "${context.styleId}" could not be read at ${workflowPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -7411,10 +7929,10 @@ var ComfyUIProvider = class _ComfyUIProvider {
           if (typeof item !== "string") {
             throw new Error(`ComfyUI ${label} must be a manifest-relative PNG or JPEG path`);
           }
-          const file = import_node_path3.default.resolve(context.root, item);
+          const file = import_node_path4.default.resolve(context.root, item);
           let bytes;
           try {
-            bytes = await (0, import_promises.readFile)(file);
+            bytes = await (0, import_promises2.readFile)(file);
           } catch (error) {
             throw new Error(
               `ComfyUI ${label} could not be read at ${file}: ${error instanceof Error ? error.message : String(error)}`
@@ -7571,7 +8089,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
         setBinding(workflow2, binding, input);
         return;
       }
-      const bytes = await (0, import_promises.readFile)(input.path);
+      const bytes = await (0, import_promises2.readFile)(input.path);
       if (sha256(bytes) !== input.sha256) {
         throw new Error(`ComfyUI provider input "${name}" changed before upload`);
       }
@@ -7638,7 +8156,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
       if (!spec.revision.sourceSha256 || !spec.revision.sourceFormat) {
         throw new Error("ComfyUI revision source is not ready");
       }
-      const sourceBytes = await (0, import_promises.readFile)(spec.revision.sourceFile);
+      const sourceBytes = await (0, import_promises2.readFile)(spec.revision.sourceFile);
       if (sha256(sourceBytes) !== spec.revision.sourceSha256) {
         throw new Error("ComfyUI revision source changed before upload");
       }
@@ -7652,7 +8170,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
         if (!spec.revision.maskSha256 || !spec.revision.maskFormat) {
           throw new Error("ComfyUI revision mask is not ready");
         }
-        const maskBytes = await (0, import_promises.readFile)(spec.revision.maskFile);
+        const maskBytes = await (0, import_promises2.readFile)(spec.revision.maskFile);
         if (sha256(maskBytes) !== spec.revision.maskSha256) {
           throw new Error("ComfyUI revision mask changed before upload");
         }
@@ -8372,9 +8890,9 @@ registerProvider({
 });
 
 // src/manifest.ts
-var import_promises3 = require("fs/promises");
-var import_node_fs6 = require("fs");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_promises4 = require("fs/promises");
+var import_node_fs7 = require("fs");
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/loop-directions.ts
 var SINGLE_OUTPUT_FIELDS = ["file", "cell", "remoteId", "source", "sourceByStyle", "outputRole"];
@@ -8462,17 +8980,17 @@ function isObject2(value) {
 }
 
 // src/outputs.ts
-var import_node_fs5 = require("fs");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs6 = require("fs");
+var import_node_path6 = __toESM(require("path"), 1);
 
 // src/lock.ts
-var import_promises2 = require("fs/promises");
-var import_node_fs4 = require("fs");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+var import_node_fs5 = require("fs");
+var import_node_path5 = __toESM(require("path"), 1);
 async function loadLock(lockPath) {
-  if (!(0, import_node_fs4.existsSync)(lockPath)) return { version: 2, entries: {} };
+  if (!(0, import_node_fs5.existsSync)(lockPath)) return { version: 2, entries: {} };
   try {
-    return parseLock(JSON.parse(await (0, import_promises2.readFile)(lockPath, "utf8")));
+    return parseLock(JSON.parse(await (0, import_promises3.readFile)(lockPath, "utf8")));
   } catch (err) {
     throw new ProjectError(
       `Lockfile at ${lockPath} is malformed:
@@ -8485,7 +9003,7 @@ var saveQueues = /* @__PURE__ */ new Map();
 var dirtyPatches = /* @__PURE__ */ new WeakMap();
 var dirtyDeletes = /* @__PURE__ */ new WeakMap();
 function saveLock(lockPath, lock) {
-  const queueKey = import_node_path4.default.resolve(lockPath);
+  const queueKey = import_node_path5.default.resolve(lockPath);
   const previous = saveQueues.get(queueKey) ?? Promise.resolve();
   const next = previous.catch(() => {
   }).then(() => writeLockNow(lockPath, lock));
@@ -8497,7 +9015,7 @@ function saveLock(lockPath, lock) {
   return next;
 }
 async function writeLockNow(lockPath, lock) {
-  await (0, import_promises2.mkdir)(import_node_path4.default.dirname(import_node_path4.default.resolve(lockPath)), { recursive: true });
+  await (0, import_promises3.mkdir)(import_node_path5.default.dirname(import_node_path5.default.resolve(lockPath)), { recursive: true });
   const release = await acquireFileLock(lockPath);
   try {
     await writeLockWhileHeld(lockPath, lock);
@@ -8507,9 +9025,9 @@ async function writeLockNow(lockPath, lock) {
 }
 async function writeLockWhileHeld(file, lock) {
   let disk = { version: 2, entries: {} };
-  if ((0, import_node_fs4.existsSync)(file)) {
+  if ((0, import_node_fs5.existsSync)(file)) {
     try {
-      disk = parseLock(JSON.parse(await (0, import_promises2.readFile)(file, "utf8")));
+      disk = parseLock(JSON.parse(await (0, import_promises3.readFile)(file, "utf8")));
     } catch (err) {
       throw new ProjectError(
         `Refusing to overwrite malformed lockfile at ${file}: ${err instanceof Error ? err.message : String(err)}`,
@@ -8538,10 +9056,10 @@ async function writeLockWhileHeld(file, lock) {
   }
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises2.writeFile)(tmp, JSON.stringify({ version: 2, entries: sorted }, null, 2) + "\n");
-    await (0, import_promises2.rename)(tmp, file);
+    await (0, import_promises3.writeFile)(tmp, JSON.stringify({ version: 2, entries: sorted }, null, 2) + "\n");
+    await (0, import_promises3.rename)(tmp, file);
   } finally {
-    await (0, import_promises2.rm)(tmp, { force: true });
+    await (0, import_promises3.rm)(tmp, { force: true });
   }
   const currentDirty = dirtyPatches.get(lock);
   if (currentDirty) {
@@ -8604,18 +9122,18 @@ async function acquireFileLock(file) {
   const deadline = Date.now() + FILE_LOCK_TIMEOUT_MS;
   for (; ; ) {
     try {
-      await (0, import_promises2.mkdir)(lockDir);
+      await (0, import_promises3.mkdir)(lockDir);
       return async () => {
-        await (0, import_promises2.rmdir)(lockDir).catch(() => {
+        await (0, import_promises3.rmdir)(lockDir).catch(() => {
         });
       };
     } catch (err) {
       const code = err.code;
       if (code !== "EEXIST") throw err;
       try {
-        const age = Date.now() - (await (0, import_promises2.stat)(lockDir)).mtimeMs;
+        const age = Date.now() - (await (0, import_promises3.stat)(lockDir)).mtimeMs;
         if (age > STALE_FILE_LOCK_MS) {
-          await (0, import_promises2.rmdir)(lockDir);
+          await (0, import_promises3.rmdir)(lockDir);
           continue;
         }
       } catch (lockErr) {
@@ -8642,22 +9160,22 @@ function totalSpend(lock, unit = "generations") {
 
 // src/outputs.ts
 function portableOutputPath(file, manifestDir) {
-  const root = import_node_path5.default.resolve(manifestDir);
-  const absolute = import_node_path5.default.isAbsolute(file) ? import_node_path5.default.normalize(file) : import_node_path5.default.resolve(root, file);
-  const relative = import_node_path5.default.relative(root, absolute);
-  const value = import_node_path5.default.isAbsolute(relative) ? absolute : relative;
-  return value.split(import_node_path5.default.sep).join("/");
+  const root = import_node_path6.default.resolve(manifestDir);
+  const absolute = import_node_path6.default.isAbsolute(file) ? import_node_path6.default.normalize(file) : import_node_path6.default.resolve(root, file);
+  const relative = import_node_path6.default.relative(root, absolute);
+  const value = import_node_path6.default.isAbsolute(relative) ? absolute : relative;
+  return value.split(import_node_path6.default.sep).join("/");
 }
 function resolveOutputPath(recordedPath, manifestDir) {
-  if (import_node_path5.default.isAbsolute(recordedPath)) return import_node_path5.default.normalize(recordedPath);
-  if (import_node_path5.default.win32.isAbsolute(recordedPath)) return recordedPath;
-  return import_node_path5.default.resolve(manifestDir, recordedPath.split(/[\\/]/).join(import_node_path5.default.sep));
+  if (import_node_path6.default.isAbsolute(recordedPath)) return import_node_path6.default.normalize(recordedPath);
+  if (import_node_path6.default.win32.isAbsolute(recordedPath)) return recordedPath;
+  return import_node_path6.default.resolve(manifestDir, recordedPath.split(/[\\/]/).join(import_node_path6.default.sep));
 }
 function expectedOutputPath(spec, role, index, total, mediaType) {
   return memberPath(spec.outFile, role, index, total, mediaType);
 }
 function memberPath(file, role, index, total, mediaType) {
-  const originalExt = import_node_path5.default.extname(file);
+  const originalExt = import_node_path6.default.extname(file);
   const ext = mediaType ? mediaExtension(mediaType) : originalExt || ".png";
   const stem = originalExt ? file.slice(0, -originalExt.length) : file;
   if (total === 1) return `${stem}${ext}`;
@@ -8671,10 +9189,10 @@ function isFrameSetEntry(entry) {
   return entry.generator === "frames" && isMemberSetEntry(entry);
 }
 function sourceIsStem(source, entry, manifestDir) {
-  return isMemberSetEntry(entry) && !(0, import_node_fs5.existsSync)(import_node_path5.default.resolve(manifestDir, source));
+  return isMemberSetEntry(entry) && !(0, import_node_fs6.existsSync)(import_node_path6.default.resolve(manifestDir, source));
 }
 function sourceOutputPath(source, entry, index, manifestDir) {
-  const absolute = import_node_path5.default.resolve(manifestDir, source);
+  const absolute = import_node_path6.default.resolve(manifestDir, source);
   if (!sourceIsStem(source, entry, manifestDir)) return absolute;
   const output = entry.outputs[index];
   return memberPath(absolute, output.role, index, entry.outputs.length, output.mediaType);
@@ -8761,7 +9279,7 @@ function resolveSpecOutputs(spec, lock, manifestDir) {
     id: spec.assetId,
     index: 0,
     path: spec.outFile,
-    absolutePath: import_node_path5.default.resolve(spec.outFile),
+    absolutePath: import_node_path6.default.resolve(spec.outFile),
     sha256: ""
   }];
 }
@@ -8774,12 +9292,17 @@ function frameSetFps(entry) {
   }
   return null;
 }
+function frameSetLoop(entry) {
+  const frameSet = entry.providerMetadata?.[entry.provider]?.frameSet;
+  const loop = frameSet && typeof frameSet === "object" ? frameSet.loop : void 0;
+  return typeof loop === "boolean" ? loop : null;
+}
 
 // src/manifest.ts
 async function loadManifest(manifestPath) {
-  const abs = import_node_path6.default.resolve(manifestPath);
-  if (!(0, import_node_fs6.existsSync)(abs)) throw new ProjectError(`No manifest at ${abs}`);
-  const expansion = expandLoopDirections(JSON.parse(await (0, import_promises3.readFile)(abs, "utf8")));
+  const abs = import_node_path7.default.resolve(manifestPath);
+  if (!(0, import_node_fs7.existsSync)(abs)) throw new ProjectError(`No manifest at ${abs}`);
+  const expansion = expandLoopDirections(JSON.parse(await (0, import_promises4.readFile)(abs, "utf8")));
   if (expansion.issues.length) {
     throw new ProjectError(`Manifest at ${abs} is invalid:
 ${expansion.issues.map((i) => `  ${i}`).join("\n")}`);
@@ -8834,7 +9357,7 @@ ${issues}`);
       if (fromStyle) {
         if (!styleIds.has(fromStyle)) {
           unknownReferences.push(`assets.${assetId}.revision.fromStyle: unknown style "${fromStyle}"`);
-        } else if (parent && parent.styles.length && !parent.styles.includes(fromStyle)) {
+        } else if (parent && !assetInStyle(parent, fromStyle, parsed.data.styles[fromStyle])) {
           unknownReferences.push(
             `assets.${assetId}.revision.fromStyle: "${asset.revision.from}" is not in style "${fromStyle}"`
           );
@@ -8881,7 +9404,11 @@ ${issues}`);
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
   const loopFamilies = Object.keys(expansion.families).length ? { loopFamilies: expansion.families } : {};
-  return { manifest: parsed.data, root: import_node_path6.default.dirname(abs), path: abs, ...loopFamilies };
+  return { manifest: parsed.data, root: import_node_path7.default.dirname(abs), path: abs, ...loopFamilies };
+}
+function assetInStyle(asset, styleId, style) {
+  if (asset.styles.length) return asset.styles.includes(styleId);
+  return style?.generator === "vfx" === Boolean(asset.vfx);
 }
 function parentAssetId(asset) {
   return asset?.revision?.from ?? asset?.state?.of ?? asset?.animation?.of ?? asset?.portrait?.of ?? asset?.outfit?.of;
@@ -8985,8 +9512,8 @@ async function resolveSpecs(loaded, filter) {
     const needed = /* @__PURE__ */ new Set();
     for (const assetId of resolutionAssetIds) {
       const asset = manifest.assets[assetId];
-      if (asset?.styles.length && !asset.styles.includes(styleId)) continue;
-      const fromStyle = asset?.revision?.fromStyle;
+      if (!asset || !assetInStyle(asset, styleId, manifest.styles[styleId])) continue;
+      const fromStyle = asset.revision?.fromStyle;
       if (fromStyle && fromStyle !== styleId) needed.add(fromStyle);
     }
     styleDependencies.set(styleId, needed);
@@ -9015,11 +9542,11 @@ async function resolveSpecs(loaded, filter) {
   const styleFinalizers = /* @__PURE__ */ new Map();
   const styleImageCache = /* @__PURE__ */ new Map();
   async function loadStyleImage(rel, what = "Style image") {
-    const abs = import_node_path6.default.resolve(root, rel);
+    const abs = import_node_path7.default.resolve(root, rel);
     let hit = styleImageCache.get(abs);
     if (!hit) {
-      if (!(0, import_node_fs6.existsSync)(abs)) throw new Error(`${what} not found: ${abs}`);
-      const buf = await (0, import_promises3.readFile)(abs);
+      if (!(0, import_node_fs7.existsSync)(abs)) throw new Error(`${what} not found: ${abs}`);
+      const buf = await (0, import_promises4.readFile)(abs);
       const metadata = imageMetadata(buf);
       if (!metadata) throw new Error(`${what} is not a readable PNG or JPEG: ${abs}`);
       if (metadata.width < 1 || metadata.height < 1) {
@@ -9045,14 +9572,14 @@ async function resolveSpecs(loaded, filter) {
       styleImageDimensions.push(loadedImage);
     }
     const resolvedImages = style.styleImages.map((image) => {
-      const hit = styleImageCache.get(import_node_path6.default.resolve(root, image.path));
+      const hit = styleImageCache.get(import_node_path7.default.resolve(root, image.path));
       return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
     });
     const styleSpecs = /* @__PURE__ */ new Map();
     const providerInputIdentities = /* @__PURE__ */ new Map();
     for (const [assetId, asset] of Object.entries(manifest.assets)) {
       if (!resolutionAssetIds.has(assetId)) continue;
-      if (asset.styles.length && !asset.styles.includes(styleId)) continue;
+      if (!assetInStyle(asset, styleId, style)) continue;
       const generator = style.generator;
       if (!activeProvider.supports(generator)) {
         throw new Error(`Provider "${activeProvider.id}" does not support generator "${generator}"`);
@@ -9072,6 +9599,15 @@ async function resolveSpecs(loaded, filter) {
       const providerInputs = inputResolution.inputs;
       const providerInputIdentity = inputResolution.identity ?? providerInputs;
       providerInputIdentities.set(assetId, providerInputIdentity);
+      if (asset.vfx && generator !== "vfx") {
+        throw new Error(`assets.${assetId}: vfx needs a vfx style; "${styleId}" generates ${generator}`);
+      }
+      if (generator === "vfx" && !asset.vfx && !asset.mirror && !asset.revision) {
+        throw new Error(
+          `assets.${assetId}: style "${styleId}" renders effects; give the asset a vfx block, or make it a mirror or revision of one`
+        );
+      }
+      const vfx = generator === "vfx" && asset.vfx ? await resolveVfxShape(root, assetId, asset.vfx, `pixelkiln:${styleId}/${assetId}`) : void 0;
       let width;
       let height;
       let size;
@@ -9099,6 +9635,11 @@ async function resolveSpecs(loaded, filter) {
         size = asset.size ?? style.size ?? 64;
         width = size;
         height = size;
+      } else if (generator === "vfx") {
+        const canvas = vfx?.recipe?.recipe.canvas;
+        width = typeof canvas?.w === "number" ? canvas.w : asset.width ?? style.size ?? 64;
+        height = typeof canvas?.h === "number" ? canvas.h : asset.height ?? style.size ?? 64;
+        size = Math.max(width, height);
       } else if (generator === "uiAsset" || generator === "uiElement") {
         width = asset.width ?? style.size ?? 256;
         height = asset.height ?? style.size ?? 256;
@@ -9141,14 +9682,14 @@ async function resolveSpecs(loaded, filter) {
         terrainUpperDescription = wrap(parsed.upper);
         terrainTransitionDescription = parsed.transition ? wrap(parsed.transition) : void 0;
         prompt = subject.trim();
-      } else if ((generator === "character" || generator === "objectPro") && characterKind !== "base") {
+      } else if ((generator === "character" || generator === "objectPro") && characterKind !== "base" || vfx) {
         prompt = subject.trim();
       } else {
         prompt = [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
       }
-      const relFile = asset.file ?? import_node_path6.default.join(asset.category ?? "", `${assetId}.png`);
-      const outFile = import_node_path6.default.resolve(root, style.outDir, relFile);
-      const qualityOutFile = style.quality ? import_node_path6.default.resolve(root, style.quality.outDir, pngPath(relFile)) : void 0;
+      const relFile = asset.file ?? import_node_path7.default.join(asset.category ?? "", `${assetId}.png`);
+      const outFile = import_node_path7.default.resolve(root, style.outDir, relFile);
+      const qualityOutFile = style.quality ? import_node_path7.default.resolve(root, style.quality.outDir, pngPath(relFile)) : void 0;
       const tileSize = generator === "tiles" ? size : style.tileSize ?? 32;
       const tileVariations = tileFeatureOutputCount(generator === "tiles" ? style.tileFeature : void 0) ?? tileVariationCount(countNumberedDescriptions(prompt));
       const terrainTiles = generator === "terrain" ? terrainTileCount(style.terrainTransitionSize) : 0;
@@ -9219,6 +9760,7 @@ async function resolveSpecs(loaded, filter) {
         // A portrait needs a character style (refused above), so an
         // objectPro asset is only ever a base, state, or animation.
         ...generator === "objectPro" && !asset.revision && characterKind !== "portrait" ? { objectPro: await resolveObjectProShape(assetId, asset, style, characterKind, { root, load: loadStyleImage }) } : {},
+        ...vfx ? { vfx } : {},
         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
@@ -9243,7 +9785,7 @@ async function resolveSpecs(loaded, filter) {
             minGridConfidence: style.quality.minGridConfidence,
             ...style.quality.minTransparency == null ? {} : { minTransparency: style.quality.minTransparency },
             ...style.quality.fixerRevision ? { fixerRevision: style.quality.fixerRevision } : {},
-            ...style.quality.fixerPython ? { fixerPython: import_node_path6.default.resolve(root, style.quality.fixerPython) } : {},
+            ...style.quality.fixerPython ? { fixerPython: import_node_path7.default.resolve(root, style.quality.fixerPython) } : {},
             ...style.quality.fps == null ? {} : { fps: style.quality.fps }
           }
         } : {},
@@ -9326,7 +9868,7 @@ async function resolveSpecs(loaded, filter) {
         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_fs6.existsSync)(file) ? await sha256File(file) : null }
+          styleAnchor: { assetId: anchorId, spec: anchorSpec, file, sha256: (0, import_node_fs7.existsSync)(file) ? await sha256File(file) : null }
         };
       }
       const characterParent = asset.state?.of ?? asset.animation?.of ?? asset.portrait?.of;
@@ -9339,7 +9881,7 @@ async function resolveSpecs(loaded, filter) {
           parentAssetId: characterParent,
           parentSpec,
           parentFile,
-          parentSha256: (0, import_node_fs6.existsSync)(parentFile) ? await sha256File(parentFile) : null,
+          parentSha256: (0, import_node_fs7.existsSync)(parentFile) ? await sha256File(parentFile) : null,
           // A state and its animations keep the engine and rotations of the base.
           mode: resolved.character.kind === "base" ? resolved.character.mode : parentSpec.character?.mode ?? resolved.character.mode,
           directions: resolved.character.kind === "base" ? resolved.character.directions : parentSpec.character?.directions ?? resolved.character.directions
@@ -9357,7 +9899,7 @@ async function resolveSpecs(loaded, filter) {
           parentAssetId: characterParent,
           parentSpec,
           parentFile,
-          parentSha256: (0, import_node_fs6.existsSync)(parentFile) ? await sha256File(parentFile) : null,
+          parentSha256: (0, import_node_fs7.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
         };
@@ -9379,7 +9921,7 @@ async function resolveSpecs(loaded, filter) {
           animation: sourceSpec.character.animation,
           outfit: {
             reference: {
-              path: import_node_path6.default.resolve(root, asset.outfit.reference),
+              path: import_node_path7.default.resolve(root, asset.outfit.reference),
               sha256: referenceImage.hash,
               width: referenceImage.width,
               height: referenceImage.height,
@@ -9402,23 +9944,23 @@ async function resolveSpecs(loaded, filter) {
         }
         const sourceStyleId = asset.revision.fromStyle && asset.revision.fromStyle !== styleId ? asset.revision.fromStyle : void 0;
         const sourceSpec = sourceStyleId ? await styleFinalizers.get(sourceStyleId)(asset.revision.from) : await finalize(asset.revision.from);
-        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? import_node_path6.default.resolve(root, sourceSpec.source) : sourceSpec.outFile);
+        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? import_node_path7.default.resolve(root, sourceSpec.source) : sourceSpec.outFile);
         const sourceMembers = await revisionSourceMembers(sourceStem, `revision source ${asset.revision.from}`);
         const sourceFile = sourceMembers?.[0]?.file ?? sourceStem;
         const sourceImage = sourceMembers ? { ...sourceMembers[0], hash: sha256(JSON.stringify(sourceMembers.map((member) => member.sha256))) } : await optionalRevisionImage(sourceFile, "revision source");
         const sourceFps = sourceSpec.character?.animation?.fps ?? sourceSpec.objectPro?.animation?.fps ?? sourceSpec.revision?.fps ?? sourceSpec.revision?.sourceFps;
-        const maskFile = asset.revision.mask ? import_node_path6.default.resolve(root, asset.revision.mask) : void 0;
+        const maskFile = asset.revision.mask ? import_node_path7.default.resolve(root, asset.revision.mask) : void 0;
         const maskImage = maskFile ? await optionalRevisionImage(maskFile, "revision mask", "png") : null;
         if (sourceImage && maskImage && (sourceImage.width !== maskImage.width || sourceImage.height !== maskImage.height)) {
           throw new Error(
             `Revision mask for ${styleId}/${assetId} is ${maskImage.width}x${maskImage.height}; source ${asset.revision.from} is ${sourceImage.width}x${sourceImage.height}`
           );
         }
-        const paletteImageFile = asset.revision.paletteImage ? import_node_path6.default.resolve(root, asset.revision.paletteImage) : void 0;
+        const paletteImageFile = asset.revision.paletteImage ? import_node_path7.default.resolve(root, asset.revision.paletteImage) : void 0;
         const paletteImage = paletteImageFile ? await optionalRevisionImage(paletteImageFile, "revision palette image", "png") : null;
-        const lastFrameFile = asset.revision.lastFrame ? import_node_path6.default.resolve(root, asset.revision.lastFrame) : void 0;
+        const lastFrameFile = asset.revision.lastFrame ? import_node_path7.default.resolve(root, asset.revision.lastFrame) : void 0;
         const lastFrame = lastFrameFile ? await optionalRevisionImage(lastFrameFile, "revision last frame") : null;
-        const keypointsFile = asset.revision.keypointsFile ? import_node_path6.default.resolve(root, asset.revision.keypointsFile) : void 0;
+        const keypointsFile = asset.revision.keypointsFile ? import_node_path7.default.resolve(root, asset.revision.keypointsFile) : void 0;
         const keypoints = keypointsFile ? await optionalSkeletonSet(keypointsFile) : null;
         resolved.revision = {
           mode: asset.revision.mode,
@@ -9588,7 +10130,7 @@ async function resolveSpecs(loaded, filter) {
   return specs;
 }
 function pngPath(file) {
-  const extension = import_node_path6.default.extname(file);
+  const extension = import_node_path7.default.extname(file);
   return extension ? `${file.slice(0, -extension.length)}.png` : `${file}.png`;
 }
 async function resolveMapScene(root, styleId, assetId, generator, scene, provider) {
@@ -9598,12 +10140,12 @@ async function resolveMapScene(root, styleId, assetId, generator, scene, provide
   if (!provider.supportsMapScene) {
     throw new Error(`assets.${assetId}.scene: provider "${provider.id}" cannot draw into a scene; PixelLab's /map-objects can`);
   }
-  const file = import_node_path6.default.resolve(root, scene.image);
+  const file = import_node_path7.default.resolve(root, scene.image);
   const image = await optionalRevisionImage(file, "scene image", "png");
   const base = { file, sha256: image?.hash ?? null, width: image?.width ?? null, height: image?.height ?? null };
   const placement = scene.placement;
   if ("mask" in placement) {
-    const maskFile = import_node_path6.default.resolve(root, placement.mask);
+    const maskFile = import_node_path7.default.resolve(root, placement.mask);
     const mask = await optionalRevisionImage(maskFile, "scene mask", "png");
     if (image && mask && (image.width !== mask.width || image.height !== mask.height)) {
       throw new Error(
@@ -9617,9 +10159,38 @@ async function resolveMapScene(root, styleId, assetId, generator, scene, provide
   }
   return "oval" in placement ? { ...base, placement: { type: "oval", fraction: placement.oval } } : { ...base, placement: { type: "rectangle", fraction: placement.rectangle } };
 }
+async function resolveVfxShape(root, assetId, vfx, defaultName) {
+  let recipe;
+  let recordedSprite;
+  if (vfx.recipe) {
+    const file = import_node_path7.default.resolve(root, vfx.recipe);
+    if (!(0, import_node_fs7.existsSync)(file)) throw new Error(`assets.${assetId}.vfx.recipe: VFX recipe not found: ${file}`);
+    const read = await readVfxRecipe(file).catch((error) => {
+      throw new Error(`assets.${assetId}.vfx.recipe: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    recipe = { file, sha256: vfxRecipeSha256(read.recipe), recipe: read.recipe };
+    recordedSprite = read.sprite;
+  }
+  const spriteRef = vfx.sprite ? isVfxReference(vfx.sprite) ? vfx.sprite : import_node_path7.default.resolve(root, vfx.sprite) : recordedSprite;
+  let sprite;
+  if (spriteRef && isVfxReference(spriteRef)) {
+    sprite = { reference: spriteRef };
+  } else if (spriteRef) {
+    const image = await optionalRevisionImage(spriteRef, `assets.${assetId}.vfx.sprite`);
+    sprite = { file: spriteRef, sha256: image?.hash ?? null, width: image?.width ?? null, height: image?.height ?? null, format: image?.format ?? null };
+  }
+  return {
+    ...vfx.preset ? { preset: vfx.preset } : {},
+    ...recipe ? { recipe } : {},
+    ...vfx.parts?.length ? { parts: vfx.parts } : {},
+    ...sprite ? { sprite } : {},
+    ...vfx.fps !== void 0 ? { fps: vfx.fps } : {},
+    name: vfx.name ?? defaultName
+  };
+}
 async function optionalRevisionImage(file, label, requiredFormat) {
-  if (!(0, import_node_fs6.existsSync)(file)) return null;
-  const bytes = await (0, import_promises3.readFile)(file);
+  if (!(0, import_node_fs7.existsSync)(file)) return null;
+  const bytes = await (0, import_promises4.readFile)(file);
   const metadata = imageMetadata(bytes);
   if (!metadata) throw new Error(`${label} is not a readable PNG or JPEG: ${file}`);
   if (requiredFormat && metadata.format !== requiredFormat) {
@@ -9628,8 +10199,8 @@ async function optionalRevisionImage(file, label, requiredFormat) {
   return { hash: sha256(bytes), ...metadata };
 }
 async function optionalSkeletonSet(file) {
-  if (!(0, import_node_fs6.existsSync)(file)) return null;
-  const bytes = await (0, import_promises3.readFile)(file);
+  if (!(0, import_node_fs7.existsSync)(file)) return null;
+  const bytes = await (0, import_promises4.readFile)(file);
   let json;
   try {
     json = JSON.parse(bytes.toString("utf8"));
@@ -9639,17 +10210,17 @@ async function optionalSkeletonSet(file) {
   return { hash: sha256(bytes), skeleton: parseSkeletonSet(json, file) };
 }
 async function revisionSourceMembers(stem, label) {
-  if ((0, import_node_fs6.existsSync)(stem)) return null;
+  if ((0, import_node_fs7.existsSync)(stem)) return null;
   const at = (role) => memberPath(stem, role, 0, 2, MediaType.PNG);
   let roles = [];
   for (const set of [CHARACTER_DIRECTIONS_8, CHARACTER_DIRECTIONS_4]) {
-    if (set.every((direction) => (0, import_node_fs6.existsSync)(at(direction)))) {
+    if (set.every((direction) => (0, import_node_fs7.existsSync)(at(direction)))) {
       roles = [...set];
       break;
     }
   }
   if (!roles.length) {
-    for (let index = 0; (0, import_node_fs6.existsSync)(at(`frame-${String(index).padStart(2, "0")}`)); index++) {
+    for (let index = 0; (0, import_node_fs7.existsSync)(at(`frame-${String(index).padStart(2, "0")}`)); index++) {
       roles.push(`frame-${String(index).padStart(2, "0")}`);
     }
   }
@@ -9675,8 +10246,8 @@ async function resolveStyleImages(loaded, styleId) {
   if (!style) throw new Error(`Unknown style "${styleId}"`);
   const out = [];
   for (const img of style.styleImages) {
-    const file = import_node_path6.default.resolve(loaded.root, img.path);
-    const buf = await (0, import_promises3.readFile)(file);
+    const file = import_node_path7.default.resolve(loaded.root, img.path);
+    const buf = await (0, import_promises4.readFile)(file);
     const metadata = imageMetadata(buf);
     if (!metadata) throw new Error(`Style image is not a readable PNG or JPEG: ${file}`);
     if (metadata.width < 1 || metadata.height < 1) {
@@ -9706,7 +10277,7 @@ async function resolveCharacterShape(asset, style, kind, files) {
   };
   if (asset.concept) {
     const image = await files.load(asset.concept, "Concept image");
-    shape.concept = { path: import_node_path6.default.resolve(files.root, asset.concept), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+    shape.concept = { path: import_node_path7.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;
@@ -9714,7 +10285,7 @@ async function resolveCharacterShape(asset, style, kind, files) {
     for (const [direction, rel] of Object.entries(byDirection)) {
       const image = await files.load(rel, `Reference sprite (${direction})`);
       shape.reference[direction] = {
-        path: import_node_path6.default.resolve(files.root, rel),
+        path: import_node_path7.default.resolve(files.root, rel),
         sha256: image.hash,
         width: image.width,
         height: image.height,
@@ -9735,7 +10306,7 @@ async function resolveCharacterShape(asset, style, kind, files) {
     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_path6.default.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      return { path: import_node_path7.default.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     };
     shape.animation = {
       mode: animationMode,
@@ -9766,7 +10337,7 @@ async function resolveObjectProShape(assetId, asset, style, kind, files) {
     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_path6.default.resolve(files.root, south), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      shape.reference = { path: import_node_path7.default.resolve(files.root, south), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     }
   }
   if (asset.state) {
@@ -9794,7 +10365,7 @@ async function resolveObjectProShape(assetId, asset, style, kind, files) {
     }
     const pose = async (rel, what) => {
       const image = await files.load(rel, what);
-      return { path: import_node_path6.default.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      return { path: import_node_path7.default.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     };
     shape.animation = {
       mode: asset.animation.mode ?? "v3",
@@ -9814,11 +10385,11 @@ function characterDirections(directions) {
 }
 
 // src/project.ts
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 
 // src/env.ts
-var import_node_fs7 = require("fs");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs8 = require("fs");
+var import_node_path8 = __toESM(require("path"), 1);
 function loadEnvFiles(dir) {
   const loaded = [];
   for (const [file, vars] of envFiles(dir)) {
@@ -9832,10 +10403,10 @@ function loadEnvFiles(dir) {
 function envFiles(dir) {
   const out = [];
   for (const name of [".env.local", ".env"]) {
-    const file = import_node_path7.default.join(dir, name);
-    if (!(0, import_node_fs7.existsSync)(file)) continue;
+    const file = import_node_path8.default.join(dir, name);
+    if (!(0, import_node_fs8.existsSync)(file)) continue;
     try {
-      out.push([file, parseEnv((0, import_node_fs7.readFileSync)(file, "utf8"))]);
+      out.push([file, parseEnv((0, import_node_fs8.readFileSync)(file, "utf8"))]);
     } catch {
     }
   }
@@ -9861,12 +10432,12 @@ function parseEnv(contents) {
 }
 
 // src/pipeline/plan.ts
-var import_node_fs10 = require("fs");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs11 = require("fs");
+var import_node_path14 = __toESM(require("path"), 1);
 
 // src/pipeline/mirror.ts
-var import_promises4 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_promises5 = require("fs/promises");
+var import_node_path9 = __toESM(require("path"), 1);
 
 // src/palette.ts
 function normalizePalette(values) {
@@ -10003,12 +10574,12 @@ async function deriveMirror(spec, lock, lockPath, opts = {}) {
   const outputs = [];
   const written = [];
   for (const [index, member] of members.entries()) {
-    const bytes = flipHorizontal(await (0, import_promises4.readFile)(member.file));
+    const bytes = flipHorizontal(await (0, import_promises5.readFile)(member.file));
     const target = expectedOutputPath(spec, member.role, index, members.length, MediaType.PNG);
-    await (0, import_promises4.mkdir)(import_node_path8.default.dirname(target), { recursive: true });
+    await (0, import_promises5.mkdir)(import_node_path9.default.dirname(target), { recursive: true });
     const tmp = `${target}.pixelkiln.tmp`;
-    await (0, import_promises4.writeFile)(tmp, bytes);
-    await (0, import_promises4.rename)(tmp, target);
+    await (0, import_promises5.writeFile)(tmp, bytes);
+    await (0, import_promises5.rename)(tmp, target);
     written.push(target);
     outputs.push({
       path: portableOutputPath(target, spec.root),
@@ -10067,20 +10638,20 @@ async function deriveMirror(spec, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/quality-profile.ts
-var import_node_fs8 = require("fs");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs9 = require("fs");
+var import_node_path12 = __toESM(require("path"), 1);
 
 // src/pipeline/refine.ts
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
-var import_promises6 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 var import_node_os3 = require("os");
 var import_node_util = require("util");
 
 // src/artifacts.ts
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_node_crypto6 = require("crypto");
-var import_promises5 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 var activeTransactions = /* @__PURE__ */ new Set();
 function message(error) {
   return error instanceof Error ? error.message : String(error);
@@ -10089,7 +10660,7 @@ function digest(data) {
   return (0, import_node_crypto6.createHash)("sha256").update(data).digest("hex");
 }
 function portableRelative(from, to) {
-  return import_node_path9.default.relative(from, import_node_path9.default.resolve(to)).split(import_node_path9.default.sep).join("/") || ".";
+  return import_node_path10.default.relative(from, import_node_path10.default.resolve(to)).split(import_node_path10.default.sep).join("/") || ".";
 }
 function canonical2(value) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
@@ -10139,12 +10710,12 @@ function parseArtifactManifest(absolute, data) {
   return raw;
 }
 async function readArtifactBundleManifest(manifestPath) {
-  const absolute = import_node_path9.default.resolve(manifestPath);
-  return parseArtifactManifest(absolute, await (0, import_promises5.readFile)(absolute, "utf8"));
+  const absolute = import_node_path10.default.resolve(manifestPath);
+  return parseArtifactManifest(absolute, await (0, import_promises6.readFile)(absolute, "utf8"));
 }
 async function readOptional(file) {
   try {
-    return await (0, import_promises5.readFile)(file);
+    return await (0, import_promises6.readFile)(file);
   } catch (error) {
     if (isCode(error, "ENOENT")) return null;
     throw error;
@@ -10163,8 +10734,8 @@ function processIsAlive(pid) {
   }
 }
 function validTemporaryPath(candidate, destination, type) {
-  return import_node_path9.default.dirname(candidate) === import_node_path9.default.dirname(destination) && import_node_path9.default.basename(candidate).startsWith(
-    `.${import_node_path9.default.basename(destination)}.pixelkiln-${type}-`
+  return import_node_path10.default.dirname(candidate) === import_node_path10.default.dirname(destination) && import_node_path10.default.basename(candidate).startsWith(
+    `.${import_node_path10.default.basename(destination)}.pixelkiln-${type}-`
   );
 }
 function parseTransaction(journal, data) {
@@ -10180,14 +10751,14 @@ function parseTransaction(journal, data) {
   return raw;
 }
 async function removeTransactionFiles(journal) {
-  await (0, import_promises5.rm)(journal, { force: true });
-  await (0, import_promises5.rm)(transactionMarker(journal), { force: true });
+  await (0, import_promises6.rm)(journal, { force: true });
+  await (0, import_promises6.rm)(transactionMarker(journal), { force: true });
 }
 async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
-  const journal = import_node_path9.default.resolve(recoveryFile);
+  const journal = import_node_path10.default.resolve(recoveryFile);
   const bytes = await readOptional(journal);
   if (!bytes) {
-    await (0, import_promises5.rm)(transactionMarker(journal), { force: true });
+    await (0, import_promises6.rm)(transactionMarker(journal), { force: true });
     return;
   }
   if (activeTransactions.has(journal)) {
@@ -10200,7 +10771,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
     );
   }
   for (const entry of transaction.entries) {
-    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(import_node_path9.default.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
+    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(import_node_path10.default.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
       throw new Error(
         `Refusing unsafe artifact recovery from ${journal}; its destinations or temporary paths do not match the current bundle.`
       );
@@ -10226,7 +10797,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
         }
         await remove2(entry.destination, errors);
         try {
-          await (0, import_promises5.rename)(entry.backup, entry.destination);
+          await (0, import_promises6.rename)(entry.backup, entry.destination);
         } catch (error) {
           errors.push(
             `could not restore ${entry.destination}; previous file remains at ${entry.backup}: ${message(error)}`
@@ -10246,7 +10817,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
   await removeTransactionFiles(journal);
 }
 function createArtifactBundleManifest(manifestPath, outputs, provenance) {
-  const root = import_node_path9.default.dirname(import_node_path9.default.resolve(manifestPath));
+  const root = import_node_path10.default.dirname(import_node_path10.default.resolve(manifestPath));
   const sources = provenance.sources.map((source) => ({
     ...source,
     path: portableRelative(root, source.path)
@@ -10276,11 +10847,11 @@ function withArtifactManifest(manifestPath, outputs, provenance) {
   ];
 }
 async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
-  const absoluteManifest = import_node_path9.default.resolve(manifestPath);
+  const absoluteManifest = import_node_path10.default.resolve(manifestPath);
   const recoveryFile = `${absoluteManifest}.transaction`;
   const allowedDestinations = /* @__PURE__ */ new Set([
     absoluteManifest,
-    ...outputs.map((output) => import_node_path9.default.resolve(output.path))
+    ...outputs.map((output) => import_node_path10.default.resolve(output.path))
   ]);
   await recoverArtifactTransaction(recoveryFile, allowedDestinations);
   const existingManifestBytes = await readOptional(absoluteManifest);
@@ -10298,13 +10869,13 @@ async function writeManagedArtifactBundle(manifestPath, outputs, provenance, opt
     }
   }
   if (!options.force) {
-    const root = import_node_path9.default.dirname(absoluteManifest);
+    const root = import_node_path10.default.dirname(absoluteManifest);
     const recorded = new Map(
-      previous?.outputs.map((output) => [import_node_path9.default.resolve(root, output.path), output.sha256]) ?? []
+      previous?.outputs.map((output) => [import_node_path10.default.resolve(root, output.path), output.sha256]) ?? []
     );
     const conflicts = [];
     for (const output of outputs) {
-      const destination = import_node_path9.default.resolve(output.path);
+      const destination = import_node_path10.default.resolve(output.path);
       const current = await readOptional(destination);
       if (!current || digest(current) === digest(output.data)) continue;
       const expected = recorded.get(destination);
@@ -10326,15 +10897,15 @@ Pass { force: true } (CLI: --force) to take ownership and replace the complete b
   );
 }
 async function verifyArtifactBundle(manifestPath) {
-  const absolute = import_node_path9.default.resolve(manifestPath);
+  const absolute = import_node_path10.default.resolve(manifestPath);
   const raw = await readArtifactBundleManifest(absolute);
-  const root = import_node_path9.default.dirname(absolute);
+  const root = import_node_path10.default.dirname(absolute);
   const changedSources = [];
   const changedOutputs = [];
   for (const source of raw.sources) {
     let actual = null;
     try {
-      actual = digest(await (0, import_promises5.readFile)(import_node_path9.default.resolve(root, source.path)));
+      actual = digest(await (0, import_promises6.readFile)(import_node_path10.default.resolve(root, source.path)));
     } catch (error) {
       if (!isCode(error, "ENOENT")) throw error;
     }
@@ -10342,7 +10913,7 @@ async function verifyArtifactBundle(manifestPath) {
   }
   for (const output of raw.outputs) {
     try {
-      if (digest(await (0, import_promises5.readFile)(import_node_path9.default.resolve(root, output.path))) !== output.sha256) {
+      if (digest(await (0, import_promises6.readFile)(import_node_path10.default.resolve(root, output.path))) !== output.sha256) {
         changedOutputs.push(output.path);
       }
     } catch (error) {
@@ -10368,7 +10939,7 @@ function isCode(error, code) {
 }
 async function remove2(file, errors) {
   try {
-    await (0, import_promises5.rm)(file, { force: true });
+    await (0, import_promises6.rm)(file, { force: true });
   } catch (error) {
     errors?.push(`could not remove ${file}: ${message(error)}`);
   }
@@ -10381,7 +10952,7 @@ async function rollback(prepared) {
   for (const artifact of [...prepared].reverse()) {
     if (!artifact.backup || !artifact.backedUp) continue;
     try {
-      await (0, import_promises5.rename)(artifact.backup, artifact.destination);
+      await (0, import_promises6.rename)(artifact.backup, artifact.destination);
       artifact.backedUp = false;
     } catch (error) {
       errors.push(
@@ -10398,7 +10969,7 @@ async function writeArtifactBundle(files, options = {}) {
   if (!files.length) throw new Error("An artifact bundle must contain at least one file.");
   const normalized = files.map((file) => {
     if (!file.path.trim()) throw new Error("Artifact paths cannot be empty.");
-    return { destination: import_node_path9.default.resolve(file.path), data: Buffer.from(file.data) };
+    return { destination: import_node_path10.default.resolve(file.path), data: Buffer.from(file.data) };
   });
   const destinations = /* @__PURE__ */ new Set();
   for (const artifact of normalized) {
@@ -10414,7 +10985,7 @@ async function writeArtifactBundle(files, options = {}) {
   const unchanged = [];
   for (const artifact of normalized) {
     try {
-      const current = await (0, import_promises5.readFile)(artifact.destination);
+      const current = await (0, import_promises6.readFile)(artifact.destination);
       if (current.equals(artifact.data)) {
         unchanged.push(artifact.destination);
       } else {
@@ -10428,21 +10999,21 @@ async function writeArtifactBundle(files, options = {}) {
   if (!changed.length) return { changed: [], unchanged };
   const token = (0, import_node_crypto6.randomUUID)();
   for (const [index, artifact] of changed.entries()) {
-    const basename = import_node_path9.default.basename(artifact.destination);
-    artifact.stage = import_node_path9.default.join(
-      import_node_path9.default.dirname(artifact.destination),
+    const basename = import_node_path10.default.basename(artifact.destination);
+    artifact.stage = import_node_path10.default.join(
+      import_node_path10.default.dirname(artifact.destination),
       `.${basename}.pixelkiln-stage-${token}-${index}`
     );
     if (artifact.existed) {
-      artifact.backup = import_node_path9.default.join(
-        import_node_path9.default.dirname(artifact.destination),
+      artifact.backup = import_node_path10.default.join(
+        import_node_path10.default.dirname(artifact.destination),
         `.${basename}.pixelkiln-backup-${token}-${index}`
       );
     }
   }
-  const journal = options.recoveryFile ? import_node_path9.default.resolve(options.recoveryFile) : null;
+  const journal = options.recoveryFile ? import_node_path10.default.resolve(options.recoveryFile) : null;
   if (journal) {
-    await (0, import_promises5.mkdir)(import_node_path9.default.dirname(journal), { recursive: true });
+    await (0, import_promises6.mkdir)(import_node_path10.default.dirname(journal), { recursive: true });
     const transaction = {
       format: "pixelkiln-artifact-transaction",
       version: 1,
@@ -10456,7 +11027,7 @@ async function writeArtifactBundle(files, options = {}) {
       }))
     };
     try {
-      await (0, import_promises5.writeFile)(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
+      await (0, import_promises6.writeFile)(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
       activeTransactions.add(journal);
     } catch (error) {
       throw new Error(
@@ -10467,9 +11038,9 @@ async function writeArtifactBundle(files, options = {}) {
   }
   try {
     for (const [index, artifact] of changed.entries()) {
-      await (0, import_promises5.mkdir)(import_node_path9.default.dirname(artifact.destination), { recursive: true });
+      await (0, import_promises6.mkdir)(import_node_path10.default.dirname(artifact.destination), { recursive: true });
       await options.beforeStage?.(artifact.destination, index);
-      await (0, import_promises5.writeFile)(artifact.stage, artifact.data, { flag: "wx" });
+      await (0, import_promises6.writeFile)(artifact.stage, artifact.data, { flag: "wx" });
     }
   } catch (error) {
     const cleanupErrors2 = await rollback(changed);
@@ -10482,17 +11053,17 @@ async function writeArtifactBundle(files, options = {}) {
   try {
     for (const artifact of changed) {
       if (!artifact.existed) continue;
-      await (0, import_promises5.rename)(artifact.destination, artifact.backup);
+      await (0, import_promises6.rename)(artifact.destination, artifact.backup);
       artifact.backedUp = true;
     }
     for (const [index, artifact] of changed.entries()) {
       await options.beforePromote?.(artifact.destination, index);
-      await (0, import_promises5.rename)(artifact.stage, artifact.destination);
+      await (0, import_promises6.rename)(artifact.stage, artifact.destination);
       artifact.stage = void 0;
       artifact.promoted = true;
     }
     if (journal) {
-      await (0, import_promises5.writeFile)(transactionMarker(journal), `${token}
+      await (0, import_promises6.writeFile)(transactionMarker(journal), `${token}
 `, { flag: "wx" });
       durableCommit = true;
       await options.afterCommit?.();
@@ -10733,16 +11304,16 @@ function sameFrameGrid(first, next) {
   return next.detection.stepX === first.detection.stepX && next.detection.stepY === first.detection.stepY && next.detection.columns === first.detection.columns && next.detection.rows === first.detection.rows && phaseMatches(next.detection.phaseX, first.detection.phaseX, first.detection.stepX) && phaseMatches(next.detection.phaseY, first.detection.phaseY, first.detection.stepY) && next.audit.width === first.audit.width && next.audit.height === first.audit.height && next.sourceWidth === first.sourceWidth && next.sourceHeight === first.sourceHeight;
 }
 async function refineAsset(options) {
-  const source = import_node_path10.default.resolve(options.source);
-  const output = import_node_path10.default.resolve(options.output);
+  const source = import_node_path11.default.resolve(options.source);
+  const output = import_node_path11.default.resolve(options.output);
   if (source === output) throw new Error("Refinement source and output must be different files.");
-  const record = import_node_path10.default.resolve(qualityRecordPath(output));
+  const record = import_node_path11.default.resolve(qualityRecordPath(output));
   const palette = normalizePalette(options.palette).map((color) => color.hex);
   const minGridConfidence = requireConfidence(options.minGridConfidence ?? "high");
   if (options.minTransparency !== void 0 && (!Number.isFinite(options.minTransparency) || options.minTransparency < 0 || options.minTransparency > 1)) throw new Error("minTransparency must be between 0 and 1.");
   let sourcePng;
   try {
-    sourcePng = decodePng(await (0, import_promises6.readFile)(source));
+    sourcePng = decodePng(await (0, import_promises7.readFile)(source));
   } catch (error) {
     throw new Error(`Cannot read refinement source ${source}: ${message2(error)}`, { cause: error });
   }
@@ -10759,8 +11330,8 @@ async function refineAsset(options) {
       );
     }
   }
-  const temp = await (0, import_promises6.mkdtemp)(import_node_path10.default.join((0, import_node_os3.tmpdir)(), "pixelkiln-refine-"));
-  const recovered = import_node_path10.default.join(temp, "native.png");
+  const temp = await (0, import_promises7.mkdtemp)(import_node_path11.default.join((0, import_node_os3.tmpdir)(), "pixelkiln-refine-"));
+  const recovered = import_node_path11.default.join(temp, "native.png");
   const fixerCommand = compatibilityCommand ?? options.fixerPython ?? process.env.PIXELKILN_PIXEL_FIXER_PYTHON ?? "python3";
   const args = compatibilityCommand ? [...options.fixerArgsPrefix ?? [], source, "--extract", recovered] : ["-c", PYTHON_FIXER_BRIDGE, source, recovered];
   try {
@@ -10781,7 +11352,7 @@ async function refineAsset(options) {
       );
     }
     const detection = parseDetection(firstJsonObject(stdout));
-    const native = decodePng(await (0, import_promises6.readFile)(recovered));
+    const native = decodePng(await (0, import_promises7.readFile)(recovered));
     const quantized = quantizeToPalette(native, palette);
     const png = encodeRgbaPng(quantized.width, quantized.height, quantized.pixels);
     const audit = auditRefinement(
@@ -10831,7 +11402,7 @@ async function refineAsset(options) {
     );
     return { source, output, record, detection, palette, audit };
   } finally {
-    await (0, import_promises6.rm)(temp, { recursive: true, force: true });
+    await (0, import_promises7.rm)(temp, { recursive: true, force: true });
   }
 }
 async function refineFrameSet(options) {
@@ -10845,18 +11416,18 @@ async function refineFrameSet(options) {
   if (roles.some((role) => !role.trim()) || new Set(roles).size !== roles.length) {
     throw new Error("Frame-set roles must be non-empty and unique.");
   }
-  const output = import_node_path10.default.resolve(options.output);
-  const record = import_node_path10.default.resolve(qualityRecordPath(output));
+  const output = import_node_path11.default.resolve(options.output);
+  const record = import_node_path11.default.resolve(qualityRecordPath(output));
   const palette = normalizeRefinementPalette(options.palette);
   const finalOutputs = options.sources.map((source, index) => qualityFrameOutputPath(output, source.role, index));
   if (new Set(finalOutputs).size !== finalOutputs.length) {
     throw new Error("Frame-set roles resolve to duplicate output filenames.");
   }
-  const sourceSet = new Set(options.sources.map((source) => import_node_path10.default.resolve(source.path)));
+  const sourceSet = new Set(options.sources.map((source) => import_node_path11.default.resolve(source.path)));
   if (finalOutputs.some((file) => sourceSet.has(file))) {
     throw new Error("Frame-set refinement sources and outputs must be different files.");
   }
-  const temp = await (0, import_promises6.mkdtemp)(import_node_path10.default.join((0, import_node_os3.tmpdir)(), "pixelkiln-refine-frames-"));
+  const temp = await (0, import_promises7.mkdtemp)(import_node_path11.default.join((0, import_node_os3.tmpdir)(), "pixelkiln-refine-frames-"));
   try {
     const frames = [];
     const outputs = [];
@@ -10864,8 +11435,8 @@ async function refineFrameSet(options) {
     const sourcePaths = [];
     let firstOptions = null;
     for (const [index, sourceEntry] of options.sources.entries()) {
-      const source = import_node_path10.default.resolve(sourceEntry.path);
-      const temporaryOutput = import_node_path10.default.join(temp, `${String(index).padStart(2, "0")}.png`);
+      const source = import_node_path11.default.resolve(sourceEntry.path);
+      const temporaryOutput = import_node_path11.default.join(temp, `${String(index).padStart(2, "0")}.png`);
       const refined = await refineAsset({
         source,
         output: temporaryOutput,
@@ -10897,7 +11468,7 @@ async function refineFrameSet(options) {
       });
       outputs.push({
         path: finalOutputs[index],
-        data: await (0, import_promises6.readFile)(temporaryOutput)
+        data: await (0, import_promises7.readFile)(temporaryOutput)
       });
     }
     const first = frames[0];
@@ -10940,23 +11511,23 @@ async function refineFrameSet(options) {
     );
     return {
       sources: sourcePaths,
-      outputs: outputs.map((item) => import_node_path10.default.resolve(item.path)),
+      outputs: outputs.map((item) => import_node_path11.default.resolve(item.path)),
       record,
       frames,
       palette,
       audit
     };
   } finally {
-    await (0, import_promises6.rm)(temp, { recursive: true, force: true });
+    await (0, import_promises7.rm)(temp, { recursive: true, force: true });
   }
 }
 async function checkQualityRecord(recordPath) {
-  const record = import_node_path10.default.resolve(recordPath);
+  const record = import_node_path11.default.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
-  const sources = manifest.sources.map((source2) => import_node_path10.default.resolve(import_node_path10.default.dirname(record), source2.path));
-  const outputs = manifest.outputs.map((output2) => import_node_path10.default.resolve(import_node_path10.default.dirname(record), output2.path));
+  const sources = manifest.sources.map((source2) => import_node_path11.default.resolve(import_node_path11.default.dirname(record), source2.path));
+  const outputs = manifest.outputs.map((output2) => import_node_path11.default.resolve(import_node_path11.default.dirname(record), output2.path));
   const source = sources[0] ?? "";
   const output = outputs[0] ?? "";
   const expectedCount = options.frameSet?.count ?? 1;
@@ -10989,7 +11560,7 @@ async function checkQualityRecord(recordPath) {
 async function approveQualityRecord(recordPath, approval) {
   const reviewer = approval.reviewer.trim();
   if (!reviewer) throw new Error("A human reviewer name is required.");
-  const record = import_node_path10.default.resolve(recordPath);
+  const record = import_node_path11.default.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
@@ -11010,14 +11581,14 @@ async function approveQualityRecord(recordPath, approval) {
       `A refinement record must contain exactly ${expectedCount} source(s) and output(s).`
     );
   }
-  const root = import_node_path10.default.dirname(record);
+  const root = import_node_path11.default.dirname(record);
   const outputs = await Promise.all(manifest.outputs.map(async (entry) => {
-    const outputPath = import_node_path10.default.resolve(root, entry.path);
-    return { path: outputPath, data: await (0, import_promises6.readFile)(outputPath) };
+    const outputPath = import_node_path11.default.resolve(root, entry.path);
+    return { path: outputPath, data: await (0, import_promises7.readFile)(outputPath) };
   }));
   const sources = manifest.sources.map((source) => ({
     ...source,
-    path: import_node_path10.default.resolve(root, source.path)
+    path: import_node_path11.default.resolve(root, source.path)
   }));
   const approved = {
     ...options,
@@ -11049,8 +11620,8 @@ async function qualitySource(spec, lock) {
     if (spec.generator === "frames") {
       return { items: null, reason: "frame-set quality requires ordered downloaded provider outputs" };
     }
-    const source = import_node_path11.default.resolve(spec.root, spec.source);
-    return (0, import_node_fs8.existsSync)(source) ? { items: [{ role: "source", path: source }] } : { items: null, reason: `declared source is missing: ${spec.source}` };
+    const source = import_node_path12.default.resolve(spec.root, spec.source);
+    return (0, import_node_fs9.existsSync)(source) ? { items: [{ role: "source", path: source }] } : { items: null, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
   if (!entry) return { items: null, reason: "raw provider output is not in the lockfile" };
@@ -11079,7 +11650,7 @@ async function qualitySource(spec, lock) {
     }
     if (role) roles.add(role);
     const source = currentEntryOutputPath(entry, spec, index);
-    if (!(0, import_node_fs8.existsSync)(source)) return { items: null, reason: `raw provider output is missing: ${source}` };
+    if (!(0, import_node_fs9.existsSync)(source)) return { items: null, reason: `raw provider output is missing: ${source}` };
     if (await sha256File(source) !== output.sha256) {
       return { items: null, reason: "raw provider output was modified after download" };
     }
@@ -11098,7 +11669,7 @@ async function inspectQualityProfile(spec, lock) {
   }
   const sourcePaths = source.items.map((item) => item.path);
   const expectedOutputs = spec.generator === "frames" ? source.items.map((item, index) => qualityFrameOutputPath(output, item.role, index)) : [output];
-  if (!(0, import_node_fs8.existsSync)(record)) {
+  if (!(0, import_node_fs9.existsSync)(record)) {
     return {
       key,
       state: "needs-refinement",
@@ -11116,7 +11687,7 @@ async function inspectQualityProfile(spec, lock) {
     const expectedRevision = spec.quality.fixerRevision ?? PIXEL_ART_FIXER_REVISION;
     const expectedTransparency = spec.quality.minTransparency ?? null;
     const expectedFrameSet = spec.generator === "frames" ? { fps: spec.quality.fps ?? 12, count: source.items.length, roles: source.items.map((item) => item.role) } : null;
-    const contractChanged = JSON.stringify(check.sources.map((item) => import_node_path11.default.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => import_node_path11.default.resolve(item))) || JSON.stringify(check.outputs.map((item) => import_node_path11.default.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => import_node_path11.default.resolve(item))) || JSON.stringify(check.options.palette.colors) !== JSON.stringify(expectedPalette) || check.options.nativeGrid.revision !== expectedRevision || check.options.audit.thresholds.minGridConfidence !== spec.quality.minGridConfidence || check.options.audit.thresholds.minTransparency !== expectedTransparency || (expectedFrameSet ? !check.options.frameSet || check.options.frameSet.fps !== expectedFrameSet.fps || check.options.frameSet.count !== expectedFrameSet.count || JSON.stringify(check.options.frameSet.roles) !== JSON.stringify(expectedFrameSet.roles) : check.options.frameSet !== void 0);
+    const contractChanged = JSON.stringify(check.sources.map((item) => import_node_path12.default.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => import_node_path12.default.resolve(item))) || JSON.stringify(check.outputs.map((item) => import_node_path12.default.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => import_node_path12.default.resolve(item))) || JSON.stringify(check.options.palette.colors) !== JSON.stringify(expectedPalette) || check.options.nativeGrid.revision !== expectedRevision || check.options.audit.thresholds.minGridConfidence !== spec.quality.minGridConfidence || check.options.audit.thresholds.minTransparency !== expectedTransparency || (expectedFrameSet ? !check.options.frameSet || check.options.frameSet.fps !== expectedFrameSet.fps || check.options.frameSet.count !== expectedFrameSet.count || JSON.stringify(check.options.frameSet.roles) !== JSON.stringify(expectedFrameSet.roles) : check.options.frameSet !== void 0);
     if (contractChanged) {
       return {
         key,
@@ -11279,8 +11850,8 @@ async function requireApprovedQualitySources(specs, lock, assetIds, outputRoles)
 }
 
 // src/pipeline/revision.ts
-var import_node_fs9 = require("fs");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_fs10 = require("fs");
+var import_node_path13 = __toESM(require("path"), 1);
 async function inspectRevisionReadiness(spec, lock) {
   if (spec.mirror) return inspectMirror(spec, lock, /* @__PURE__ */ new Set());
   if (spec.character?.kind === "outfit") return inspectOutfit(spec, lock, /* @__PURE__ */ new Set());
@@ -11288,6 +11859,7 @@ async function inspectRevisionReadiness(spec, lock) {
   if (spec.character?.styleAnchor) return inspectStyleAnchor(spec, lock, /* @__PURE__ */ new Set());
   if (spec.objectPro?.parentSpec) return inspectObjectProParent(spec, lock, /* @__PURE__ */ new Set());
   if (spec.scene) return inspectScene(spec);
+  if (spec.vfx?.sprite && "file" in spec.vfx.sprite) return inspectVfxSprite(spec);
   if (!spec.revision) return null;
   return inspectRevision(spec, lock, /* @__PURE__ */ new Set());
 }
@@ -11296,7 +11868,7 @@ async function inspectStyleAnchor(spec, lock, seen) {
   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_fs9.existsSync)(anchor.file)) return { ready: false, reason: `${label} has no generated south-facing file yet` };
+  if (!anchor.sha256 || !(0, import_node_fs10.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` };
   }
@@ -11310,11 +11882,17 @@ async function inspectScene(spec) {
   const files = [{ label: "scene image", file: scene.file, sha256: scene.sha256 }];
   if (scene.placement.type === "mask") files.push({ label: "scene mask", file: scene.placement.file, sha256: scene.placement.sha256 });
   for (const { label, file, sha256: sha2562 } of files) {
-    if (!sha2562 || !(0, import_node_fs9.existsSync)(file)) return { ready: false, reason: `${label} does not exist yet: ${file}` };
+    if (!sha2562 || !(0, import_node_fs10.existsSync)(file)) return { ready: false, reason: `${label} does not exist yet: ${file}` };
     if (await sha256File(file) !== sha2562) return { ready: false, reason: `${label} changed after the manifest was resolved` };
   }
   return { ready: true, reason: "scene is current" };
 }
+async function inspectVfxSprite(spec) {
+  const sprite = spec.vfx.sprite;
+  if (!sprite.sha256 || !(0, import_node_fs10.existsSync)(sprite.file)) return { ready: false, reason: `vfx sprite does not exist yet: ${sprite.file}` };
+  if (await sha256File(sprite.file) !== sprite.sha256) return { ready: false, reason: "vfx sprite changed after the manifest was resolved" };
+  return { ready: true, reason: "vfx sprite is current" };
+}
 async function inspectMirror(spec, lock, seen) {
   const source = spec.mirror.sourceSpec;
   const label = `mirror source ${spec.styleId}/${spec.mirror.sourceAssetId}`;
@@ -11327,7 +11905,7 @@ async function inspectOutfit(spec, lock, seen) {
   const label = `outfit source ${spec.styleId}/${character.parentAssetId}`;
   const dependency = await inspectParent(character.parentSpec, lock, seen);
   if (!dependency.ready) return { ready: false, reason: `${label} is not ready: ${dependency.reason}` };
-  if (!(0, import_node_fs9.existsSync)(outfit.reference.path)) {
+  if (!(0, import_node_fs10.existsSync)(outfit.reference.path)) {
     return { ready: false, reason: `outfit reference is missing: ${outfit.reference.path}` };
   }
   if (await sha256File(outfit.reference.path) !== outfit.reference.sha256) {
@@ -11341,7 +11919,7 @@ async function inspectCharacterParent(spec, lock, seen) {
   const label = `${character.kind} parent ${spec.styleId}/${character.parentAssetId}`;
   const dependency = await inspectParent(parentSpec, lock, seen);
   if (!dependency.ready) return { ready: false, reason: `${label} is not ready: ${dependency.reason}` };
-  if (!character.parentSha256 || !character.parentFile || !(0, import_node_fs9.existsSync)(character.parentFile)) {
+  if (!character.parentSha256 || !character.parentFile || !(0, import_node_fs10.existsSync)(character.parentFile)) {
     return { ready: false, reason: `${label} has no generated south-facing file yet` };
   }
   if (await sha256File(character.parentFile) !== character.parentSha256) {
@@ -11359,7 +11937,7 @@ async function inspectObjectProParent(spec, lock, seen) {
   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_fs9.existsSync)(object.parentFile)) {
+  if (!object.parentSha256 || !object.parentFile || !(0, import_node_fs10.existsSync)(object.parentFile)) {
     return { ready: false, reason: `${label} has no generated south-facing file yet` };
   }
   if (await sha256File(object.parentFile) !== object.parentSha256) {
@@ -11385,7 +11963,7 @@ async function inspectRevision(spec, lock, seen) {
     const members = await inspectSourceMembers(spec, lock);
     if (!members.ready) return members;
   } else {
-    if (!revision.sourceSha256 || !(0, import_node_fs9.existsSync)(revision.sourceFile)) {
+    if (!revision.sourceSha256 || !(0, import_node_fs10.existsSync)(revision.sourceFile)) {
       return { ready: false, reason: `revision source is missing: ${revision.sourceFile}` };
     }
     if (await sha256File(revision.sourceFile) !== revision.sourceSha256) {
@@ -11393,7 +11971,7 @@ async function inspectRevision(spec, lock, seen) {
     }
   }
   if (revision.maskFile) {
-    if (!revision.maskSha256 || !(0, import_node_fs9.existsSync)(revision.maskFile)) {
+    if (!revision.maskSha256 || !(0, import_node_fs10.existsSync)(revision.maskFile)) {
       return { ready: false, reason: `revision mask is missing: ${revision.maskFile}` };
     }
     if (await sha256File(revision.maskFile) !== revision.maskSha256) {
@@ -11401,7 +11979,7 @@ async function inspectRevision(spec, lock, seen) {
     }
   }
   if (revision.lastFrameFile) {
-    if (!revision.lastFrameSha256 || !(0, import_node_fs9.existsSync)(revision.lastFrameFile)) {
+    if (!revision.lastFrameSha256 || !(0, import_node_fs10.existsSync)(revision.lastFrameFile)) {
       return { ready: false, reason: `revision last frame is missing: ${revision.lastFrameFile}` };
     }
     if (await sha256File(revision.lastFrameFile) !== revision.lastFrameSha256) {
@@ -11414,7 +11992,7 @@ async function inspectSourceMembers(spec, lock) {
   const revision = spec.revision;
   const members = revision.sourceMembers;
   for (const member of members) {
-    if (!(0, import_node_fs9.existsSync)(member.file)) return { ready: false, reason: `revision source member is missing: ${member.file}` };
+    if (!(0, import_node_fs10.existsSync)(member.file)) return { ready: false, reason: `revision source member is missing: ${member.file}` };
     if (await sha256File(member.file) !== member.sha256) {
       return { ready: false, reason: `revision source member changed after the manifest was resolved: ${member.file}` };
     }
@@ -11423,8 +12001,8 @@ async function inspectSourceMembers(spec, lock) {
   if (parent.source) return { ready: true, reason: "declared source set is present" };
   const entry = lock.entries[lockKey(parent.styleId, parent.assetId)];
   if (!entry) return { ready: false, reason: "revision source is not in the lockfile" };
-  const recorded = entry.outputs.map((_, index) => import_node_path12.default.resolve(currentEntryOutputPath(entry, parent, index))).sort();
-  const found = members.map((member) => import_node_path12.default.resolve(member.file)).sort();
+  const recorded = entry.outputs.map((_, index) => import_node_path13.default.resolve(currentEntryOutputPath(entry, parent, index))).sort();
+  const found = members.map((member) => import_node_path13.default.resolve(member.file)).sort();
   if (recorded.length !== found.length || recorded.some((file, index) => file !== found[index])) {
     return {
       ready: false,
@@ -11473,8 +12051,8 @@ async function inspectParent(spec, lock, seen) {
     };
   }
   if (spec.source) {
-    const source = import_node_path12.default.resolve(spec.root, spec.source);
-    return (0, import_node_fs9.existsSync)(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
+    const source = import_node_path13.default.resolve(spec.root, spec.source);
+    return (0, import_node_fs10.existsSync)(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
   }
   const entry = lock.entries[key];
   if (!entry) return { ready: false, reason: "parent is not in the lockfile" };
@@ -11488,7 +12066,7 @@ async function inspectParent(spec, lock, seen) {
   for (let index = 0; index < entry.outputs.length; index++) {
     const output = entry.outputs[index];
     const file = currentEntryOutputPath(entry, spec, index);
-    if (!(0, import_node_fs9.existsSync)(file)) return { ready: false, reason: `parent output is missing: ${file}` };
+    if (!(0, import_node_fs10.existsSync)(file)) return { ready: false, reason: `parent output is missing: ${file}` };
     if (await sha256File(file) !== output.sha256) {
       return { ready: false, reason: `parent output was modified: ${file}` };
     }
@@ -11551,8 +12129,8 @@ async function buildPlan(specs, lock, opts = {}) {
     } else if (opts.force) {
       state = "missing";
       reason = "--force";
-    } else if (!entry && spec.source && spec.generator !== "frames") {
-      if ((0, import_node_fs10.existsSync)(import_node_path13.default.resolve(spec.root, spec.source))) {
+    } else if (!entry && spec.source && spec.generator !== "frames" && spec.generator !== "vfx") {
+      if ((0, import_node_fs11.existsSync)(import_node_path14.default.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -11560,7 +12138,7 @@ async function buildPlan(specs, lock, opts = {}) {
         reason = `declared source is missing: ${spec.source}`;
       }
     } else if (!entry) {
-      if ((0, import_node_fs10.existsSync)(spec.outFile)) {
+      if ((0, import_node_fs11.existsSync)(spec.outFile)) {
         state = "untracked";
         reason = "file on disk, no provenance recorded";
       } else {
@@ -11573,7 +12151,7 @@ async function buildPlan(specs, lock, opts = {}) {
     } else if (spec.mirror && !mirrorCurrent(entry, lock.entries[lockKey(spec.styleId, spec.mirror.sourceAssetId)])) {
       state = "stale";
       reason = `mirror source ${spec.mirror.sourceAssetId} changed; flip it again (no generation cost)`;
-    } else if (spec.mirror && entry.status === "downloaded" && entry.outputs.some((_output, index) => !(0, import_node_fs10.existsSync)(currentEntryOutputPath(entry, spec, index)))) {
+    } else if (spec.mirror && entry.status === "downloaded" && entry.outputs.some((_output, index) => !(0, import_node_fs11.existsSync)(currentEntryOutputPath(entry, spec, index)))) {
       state = "stale";
       reason = "mirror output missing on disk; flip it again (no generation cost)";
     } else if (spec.character?.kind === "outfit" && entry.outfit?.sourceSha256 !== mirrorSourceHash(lock.entries[lockKey(spec.styleId, spec.character.parentAssetId)] ?? { outputs: [] })) {
@@ -11601,9 +12179,9 @@ async function buildPlan(specs, lock, opts = {}) {
     } else if (entry.status !== "downloaded") {
       state = "in-flight";
       reason = `awaiting ${entry.status}`;
-    } else if (entry.outputs.length === 0 || entry.outputs.some((_output, index) => !(0, import_node_fs10.existsSync)(currentEntryOutputPath(entry, spec, index)))) {
+    } else if (entry.outputs.length === 0 || entry.outputs.some((_output, index) => !(0, import_node_fs11.existsSync)(currentEntryOutputPath(entry, spec, index)))) {
       state = "orphaned";
-      reason = entry.outputs.length === 0 ? "no recorded output files" : `missing on disk: ${entry.outputs.filter((_output, index) => !(0, import_node_fs10.existsSync)(currentEntryOutputPath(entry, spec, index))).map((o) => o.role ?? "asset").join(", ")}`;
+      reason = entry.outputs.length === 0 ? "no recorded output files" : `missing on disk: ${entry.outputs.filter((_output, index) => !(0, import_node_fs11.existsSync)(currentEntryOutputPath(entry, spec, index))).map((o) => o.role ?? "asset").join(", ")}`;
     } else if (await anyOutputModified(entry, spec)) {
       state = "orphaned";
       reason = "output modified since download";
@@ -11694,13 +12272,13 @@ function summarize(plan) {
 
 // src/project.ts
 async function openProject(manifestPath = "pixelkiln.manifest.json", opts = {}) {
-  const absolute = import_node_path14.default.resolve(manifestPath);
-  const root = import_node_path14.default.dirname(absolute);
+  const absolute = import_node_path15.default.resolve(manifestPath);
+  const root = import_node_path15.default.dirname(absolute);
   if (opts.env !== false) {
     loadEnvFiles(root);
-    if (import_node_path14.default.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
+    if (import_node_path15.default.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
   }
-  const lockPath = import_node_path14.default.resolve(opts.lockPath ?? import_node_path14.default.join(root, "pixelkiln.lock.json"));
+  const lockPath = import_node_path15.default.resolve(opts.lockPath ?? import_node_path15.default.join(root, "pixelkiln.lock.json"));
   const loaded = await loadManifest(absolute);
   const specs = await resolveSpecs(loaded, { styles: opts.styles ?? [], assets: opts.assets ?? [] });
   const lock = await loadLock(lockPath);
@@ -11767,9 +12345,9 @@ function shouldPersistSourceUrl(value) {
 }
 
 // src/recipes.ts
-var import_node_path15 = __toESM(require("path"), 1);
-var import_node_fs11 = require("fs");
-var import_promises7 = require("fs/promises");
+var import_node_path16 = __toESM(require("path"), 1);
+var import_node_fs12 = require("fs");
+var import_promises8 = require("fs/promises");
 var import_node_url = require("url");
 var import_zod4 = require("zod");
 var SHA256_RE = /^[0-9a-f]{64}$/;
@@ -11778,7 +12356,7 @@ var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
 var PortablePathSchema = import_zod4.z.string().min(1).refine((value) => {
-  if (value.includes("\\") || import_node_path15.default.posix.isAbsolute(value)) return false;
+  if (value.includes("\\") || import_node_path16.default.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
@@ -11954,10 +12532,10 @@ function message3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = import_node_path15.default.resolve(recipePath);
+  const absolute = import_node_path16.default.resolve(recipePath);
   let raw;
   try {
-    raw = JSON.parse(await (0, import_promises7.readFile)(absolute, "utf8"));
+    raw = JSON.parse(await (0, import_promises8.readFile)(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read recipe ${absolute}: ${message3(error)}`, { cause: error });
   }
@@ -11968,13 +12546,13 @@ async function readRecipeFile(recipePath, bundled) {
 ` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
     );
   }
-  return { recipe: parsed.data, authored: raw, path: absolute, dir: import_node_path15.default.dirname(absolute), bundled };
+  return { recipe: parsed.data, authored: raw, path: absolute, dir: import_node_path16.default.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
-  if (!(0, import_node_fs11.existsSync)(root)) return [];
+  if (!(0, import_node_fs12.existsSync)(root)) return [];
   const out = [];
-  for (const entry of await (0, import_promises7.readdir)(root, { withFileTypes: true })) {
-    const resolved = import_node_path15.default.join(root, entry.name);
+  for (const entry of await (0, import_promises8.readdir)(root, { withFileTypes: true })) {
+    const resolved = import_node_path16.default.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -11985,7 +12563,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(import_node_path15.default.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(import_node_path16.default.resolve(root))).map((file) => readRecipeFile(file, true))
   );
   return recipes.sort(
     (a, b) => a.recipe.id.localeCompare(b.recipe.id) || compareVersions(b.recipe.version, a.recipe.version)
@@ -12008,9 +12586,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = import_node_path15.default.resolve(target);
-  if ((0, import_node_fs11.existsSync)(local)) {
-    const recipePath = import_node_path15.default.basename(local) === RECIPE_FILE ? local : import_node_path15.default.join(local, RECIPE_FILE);
+  const local = import_node_path16.default.resolve(target);
+  if ((0, import_node_fs12.existsSync)(local)) {
+    const recipePath = import_node_path16.default.basename(local) === RECIPE_FILE ? local : import_node_path16.default.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -12024,8 +12602,8 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = import_node_path15.default.resolve(root, ...file.path.split("/"));
-  if (!(0, import_node_fs11.existsSync)(absolute)) {
+  const absolute = import_node_path16.default.resolve(root, ...file.path.split("/"));
+  if (!(0, import_node_fs12.existsSync)(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
   const actualSha256 = await sha256File(absolute);
@@ -12040,7 +12618,7 @@ async function verifyRecipe(target, options = {}) {
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const actualIntegrity = recipeDigest(loaded.authored);
   const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
-  const modelRoot = options.modelRoot ? import_node_path15.default.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? import_node_path16.default.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -12074,7 +12652,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = import_node_path15.default.relative(cwd, destination).split(import_node_path15.default.sep).join("/") || ".";
+  const portableDir = import_node_path16.default.relative(cwd, destination).split(import_node_path16.default.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -12086,25 +12664,25 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = import_node_path15.default.resolve(options.cwd ?? process.cwd());
+  const cwd = import_node_path16.default.resolve(options.cwd ?? process.cwd());
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const verification = await verifyRecipe(loaded.path);
   if (!verification.ok) {
     throw new Error(`Recipe ${loaded.recipe.id}@${loaded.recipe.version} failed integrity verification.`);
   }
-  const destination = options.out ? import_node_path15.default.resolve(cwd, options.out) : import_node_path15.default.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? import_node_path16.default.resolve(cwd, options.out) : import_node_path16.default.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
   const sources = [
     { path: RECIPE_FILE, source: loaded.path },
-    ...loaded.recipe.files.map((file) => ({ path: file.path, source: import_node_path15.default.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: import_node_path16.default.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: import_node_path15.default.join(destination, ...file.path.split("/")),
-    data: await (0, import_promises7.readFile)(file.source)
+    path: import_node_path16.default.join(destination, ...file.path.split("/")),
+    data: await (0, import_promises8.readFile)(file.source)
   })));
   if (!options.force) {
     for (const file of files) {
-      if (!(0, import_node_fs11.existsSync)(file.path)) continue;
-      const current = await (0, import_promises7.readFile)(file.path);
+      if (!(0, import_node_fs12.existsSync)(file.path)) continue;
+      const current = await (0, import_promises8.readFile)(file.path);
       if (!current.equals(file.data)) {
         throw new OverwriteRefusedError(
           `Recipe destination has local changes: ${file.path}. Choose another --out or pass --force to replace declared recipe files.`,
@@ -12128,9 +12706,9 @@ async function installRecipe(target, options = {}) {
 }
 
 // src/pipeline/audit.ts
-var import_promises8 = require("fs/promises");
-var import_node_fs12 = require("fs");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_promises9 = require("fs/promises");
+var import_node_fs13 = require("fs");
+var import_node_path17 = __toESM(require("path"), 1);
 function paletteDistance(asset, reference) {
   if (!asset.length || !reference.length) return 0;
   let total = 0;
@@ -12166,12 +12744,12 @@ async function auditStyle(loaded, specs, styleId, lock) {
   const unreadable = [];
   for (const spec of mine) {
     for (const output of resolveSpecOutputs(spec, lock, loaded.root)) {
-      if (!(0, import_node_fs12.existsSync)(output.absolutePath)) {
+      if (!(0, import_node_fs13.existsSync)(output.absolutePath)) {
         missing.push(output.id);
         continue;
       }
       try {
-        const png = decodePng(await (0, import_promises8.readFile)(output.absolutePath));
+        const png = decodePng(await (0, import_promises9.readFile)(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -12195,10 +12773,10 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = import_node_path16.default.resolve(loaded.root, img.path);
-    if (!(0, import_node_fs12.existsSync)(abs)) continue;
+    const abs = import_node_path17.default.resolve(loaded.root, img.path);
+    if (!(0, import_node_fs13.existsSync)(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await (0, import_promises8.readFile)(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await (0, import_promises9.readFile)(abs)), 12));
     } catch {
     }
   }
@@ -12274,20 +12852,20 @@ function hex(c) {
 }
 
 // src/pixellab-utils.ts
-var import_node_fs13 = require("fs");
-var import_promises9 = require("fs/promises");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_fs14 = require("fs");
+var import_promises10 = require("fs/promises");
+var import_node_path18 = __toESM(require("path"), 1);
 var UNZOOM_MIN_SIDE = 256;
 var UNZOOM_MAX_AREA = 2048 * 2048;
 function defaultUnzoomOut(input) {
-  const ext = import_node_path17.default.extname(input);
+  const ext = import_node_path18.default.extname(input);
   return `${ext ? input.slice(0, -ext.length) : input}.unzoomed.png`;
 }
 async function unzoomFile(client2, input, opts = {}) {
-  const out = import_node_path17.default.resolve(opts.out ?? defaultUnzoomOut(input));
-  if (import_node_path17.default.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
-  if ((0, import_node_fs13.existsSync)(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
-  const bytes = await (0, import_promises9.readFile)(input);
+  const out = import_node_path18.default.resolve(opts.out ?? defaultUnzoomOut(input));
+  if (import_node_path18.default.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
+  if ((0, import_node_fs14.existsSync)(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
+  const bytes = await (0, import_promises10.readFile)(input);
   const metadata = imageMetadata(bytes);
   if (!metadata) throw new Error(`${input} is not a readable PNG or JPEG`);
   const { width, height, format } = metadata;
@@ -12300,22 +12878,22 @@ async function unzoomFile(client2, input, opts = {}) {
     throw new Error(`${input} is ${width}x${height}; PixelLab's unzoom takes at most 2048x2048 worth of pixels`);
   }
   const res = await client2.unzoom({ image: { base64: bytes.toString("base64"), format }, quantize: opts.quantize });
-  await (0, import_promises9.mkdir)(import_node_path17.default.dirname(out), { recursive: true });
-  await (0, import_promises9.writeFile)(out, res.png);
+  await (0, import_promises10.mkdir)(import_node_path18.default.dirname(out), { recursive: true });
+  await (0, import_promises10.writeFile)(out, res.png);
   return { out, original: res.originalSize, unzoomed: res.unzoomedSize, zoomFactor: res.zoomFactor, usage: res.usage };
 }
 var FONT_WEIGHTS = ["Bold", "Regular"];
 var FONT_GLYPH_SIZES = [8, 16, 32, 64];
 var FONT_COST_GENERATIONS = 15;
 function fontOutputPaths(out) {
-  const base = import_node_path17.default.resolve(out.replace(/\.(ttf|png)$/i, ""));
+  const base = import_node_path18.default.resolve(out.replace(/\.(ttf|png)$/i, ""));
   return { ttf: `${base}.ttf`, atlas: `${base}.png` };
 }
 async function generateFont(client2, opts) {
   const { ttf, atlas } = fontOutputPaths(opts.out);
   if (!opts.force) {
     for (const file of [ttf, atlas]) {
-      if ((0, import_node_fs13.existsSync)(file)) throw new Error(`${file} already exists; pass --force to replace it`);
+      if ((0, import_node_fs14.existsSync)(file)) throw new Error(`${file} already exists; pass --force to replace it`);
     }
   }
   const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
@@ -12342,9 +12920,9 @@ async function generateFont(client2, opts) {
         client2.download(job.download_ttf_url),
         client2.download(job.download_atlas_url)
       ]);
-      await (0, import_promises9.mkdir)(import_node_path17.default.dirname(ttf), { recursive: true });
-      await (0, import_promises9.writeFile)(ttf, ttfBytes);
-      await (0, import_promises9.writeFile)(atlas, atlasBytes);
+      await (0, import_promises10.mkdir)(import_node_path18.default.dirname(ttf), { recursive: true });
+      await (0, import_promises10.writeFile)(ttf, ttfBytes);
+      await (0, import_promises10.writeFile)(atlas, atlasBytes);
       return { jobId, ttf, atlas, glyphPx: job.glyph_px ?? null, usage: job.usage };
     }
     if (Date.now() - started > timeout) {
@@ -12358,14 +12936,14 @@ async function generateFont(client2, opts) {
 var PIXELATE_COST_GENERATIONS = 6;
 var PIXELATE_MAX_SIDE = 2048;
 function defaultPixelateOut(input) {
-  const ext = import_node_path17.default.extname(input);
+  const ext = import_node_path18.default.extname(input);
   return `${ext ? input.slice(0, -ext.length) : input}.pixel.png`;
 }
 async function pixelateFile(client2, input, opts = {}) {
-  const out = import_node_path17.default.resolve(opts.out ?? defaultPixelateOut(input));
-  if (import_node_path17.default.resolve(input) === out) throw new Error("pixelate will not overwrite its own input; pass a different --out");
-  if ((0, import_node_fs13.existsSync)(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
-  const bytes = await (0, import_promises9.readFile)(input);
+  const out = import_node_path18.default.resolve(opts.out ?? defaultPixelateOut(input));
+  if (import_node_path18.default.resolve(input) === out) throw new Error("pixelate will not overwrite its own input; pass a different --out");
+  if ((0, import_node_fs14.existsSync)(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
+  const bytes = await (0, import_promises10.readFile)(input);
   const metadata = imageMetadata(bytes);
   if (!metadata) throw new Error(`${input} is not a readable PNG or JPEG`);
   const { width, height, format } = metadata;
@@ -12391,8 +12969,8 @@ async function pixelateFile(client2, input, opts = {}) {
       }
       const png = Buffer.from(first.base64, "base64");
       const size = imageMetadata(png);
-      await (0, import_promises9.mkdir)(import_node_path17.default.dirname(out), { recursive: true });
-      await (0, import_promises9.writeFile)(out, png);
+      await (0, import_promises10.mkdir)(import_node_path18.default.dirname(out), { recursive: true });
+      await (0, import_promises10.writeFile)(out, png);
       return {
         jobId,
         out,
@@ -12412,15 +12990,15 @@ async function pixelateFile(client2, input, opts = {}) {
 }
 
 // src/pipeline/quality-regression.ts
-var import_node_path18 = __toESM(require("path"), 1);
-var import_node_fs14 = require("fs");
-var import_promises10 = require("fs/promises");
+var import_node_path19 = __toESM(require("path"), 1);
+var import_node_fs15 = require("fs");
+var import_promises11 = require("fs/promises");
 var import_zod5 = require("zod");
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
 var QualityPathSchema = import_zod5.z.string().min(1).refine(
-  (value) => !import_node_path18.default.posix.isAbsolute(value) && !value.includes("\\"),
+  (value) => !import_node_path19.default.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -12567,10 +13145,10 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = import_node_path18.default.resolve(file);
+  const absolute = import_node_path19.default.resolve(file);
   let bytes;
   try {
-    bytes = await (0, import_promises10.readFile)(absolute);
+    bytes = await (0, import_promises11.readFile)(absolute);
   } catch (error) {
     throw new Error(`Cannot read quality image ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -12589,11 +13167,11 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }
   const ids = parsed.data.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) throw new Error("--inputs contains a duplicate quality case id.");
-  const root = import_node_path18.default.dirname(import_node_path18.default.resolve(inputsFilePath));
+  const root = import_node_path19.default.dirname(import_node_path19.default.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: import_node_path18.default.resolve(root, entry.path),
-    ...entry.record ? { record: import_node_path18.default.resolve(root, entry.record) } : {},
+    file: import_node_path19.default.resolve(root, entry.path),
+    ...entry.record ? { record: import_node_path19.default.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -12601,7 +13179,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return import_node_path18.default.relative(from, import_node_path18.default.resolve(to)).split(import_node_path18.default.sep).join("/") || ".";
+  return import_node_path19.default.relative(from, import_node_path19.default.resolve(to)).split(import_node_path19.default.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -12616,20 +13194,20 @@ async function verifyRecordForImage(recordPath, imagePath) {
   if (record.kind !== "refine" || options === null || typeof options !== "object" || options.schema !== "pixelkiln-quality") {
     throw new Error(`Quality record ${recordPath} is not a PixelKiln refinement record.`);
   }
-  const outputs = record.outputs.map((output) => import_node_path18.default.resolve(import_node_path18.default.dirname(recordPath), output.path));
-  if (!outputs.includes(import_node_path18.default.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => import_node_path19.default.resolve(import_node_path19.default.dirname(recordPath), output.path));
+  if (!outputs.includes(import_node_path19.default.resolve(imagePath))) {
     throw new Error(`Quality record ${recordPath} does not own ${imagePath}.`);
   }
 }
 async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   if (!inputs.length) throw new Error("Cannot snapshot an empty quality baseline.");
-  const absolute = import_node_path18.default.resolve(baselinePath);
+  const absolute = import_node_path19.default.resolve(baselinePath);
   for (const input of inputs) {
-    if (import_node_path18.default.resolve(input.file) === absolute || input.record && import_node_path18.default.resolve(input.record) === absolute) {
+    if (import_node_path19.default.resolve(input.file) === absolute || input.record && import_node_path19.default.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = import_node_path18.default.dirname(absolute);
+  const root = import_node_path19.default.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -12656,8 +13234,8 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
     cases
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
-  if ((0, import_node_fs14.existsSync)(absolute) && !options.force) {
-    const current = await (0, import_promises10.readFile)(absolute);
+  if ((0, import_node_fs15.existsSync)(absolute) && !options.force) {
+    const current = await (0, import_promises11.readFile)(absolute);
     if (!current.equals(data)) {
       throw new OverwriteRefusedError(
         `Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`,
@@ -12669,10 +13247,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = import_node_path18.default.resolve(baselinePath);
+  const absolute = import_node_path19.default.resolve(baselinePath);
   let raw;
   try {
-    raw = JSON.parse(await (0, import_promises10.readFile)(absolute, "utf8"));
+    raw = JSON.parse(await (0, import_promises11.readFile)(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read quality baseline ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -12742,12 +13320,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = import_node_path18.default.resolve(baselinePath);
+  const absolute = import_node_path19.default.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = import_node_path18.default.dirname(absolute);
+  const root = import_node_path19.default.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = import_node_path18.default.resolve(root, entry.file);
+    const file = import_node_path19.default.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -12760,7 +13338,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message4(error));
     }
     if (entry.record) {
-      const recordPath = import_node_path18.default.resolve(root, entry.record.path);
+      const recordPath = import_node_path19.default.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -12796,14 +13374,14 @@ async function checkQualityBaseline(baselinePath) {
 }
 
 // src/pipeline/cache-health.ts
-var import_node_fs18 = require("fs");
-var import_promises13 = require("fs/promises");
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_fs19 = require("fs");
+var import_promises14 = require("fs/promises");
+var import_node_path23 = __toESM(require("path"), 1);
 
 // src/cache.ts
-var import_promises11 = require("fs/promises");
-var import_node_fs15 = require("fs");
-var import_node_path19 = __toESM(require("path"), 1);
+var import_promises12 = require("fs/promises");
+var import_node_fs16 = require("fs");
+var import_node_path20 = __toESM(require("path"), 1);
 var import_zod6 = require("zod");
 var HashCacheSchema = import_zod6.z.object({
   version: import_zod6.z.literal(1),
@@ -12817,10 +13395,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path38) {
-  if (!(0, import_node_fs15.existsSync)(path38)) return { version: 1, hashes: {} };
+async function loadCache(path39) {
+  if (!(0, import_node_fs16.existsSync)(path39)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises11.readFile)(path38, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises12.readFile)(path39, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -12832,20 +13410,20 @@ async function loadCache(path38) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path38, cache) {
+async function saveCache(path39, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await (0, import_promises11.mkdir)(import_node_path19.default.dirname(import_node_path19.default.resolve(path38)), { recursive: true });
-  const tmp = `${path38}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await (0, import_promises12.mkdir)(import_node_path20.default.dirname(import_node_path20.default.resolve(path39)), { recursive: true });
+  const tmp = `${path39}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises11.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await (0, import_promises11.rename)(tmp, path38);
+    await (0, import_promises12.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
+    await (0, import_promises12.rename)(tmp, path39);
   } finally {
-    await (0, import_promises11.rm)(tmp, { force: true });
+    await (0, import_promises12.rm)(tmp, { force: true });
   }
 }
 function pruneCache(cache, liveIds, namespace = "") {
@@ -12867,20 +13445,20 @@ function cachePathFor(lockPath) {
 }
 
 // src/pipeline/history.ts
-var import_node_fs17 = require("fs");
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_fs18 = require("fs");
+var import_node_path22 = __toESM(require("path"), 1);
 
 // src/pipeline/fetch.ts
-var import_node_fs16 = require("fs");
-var import_promises12 = require("fs/promises");
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_fs17 = require("fs");
+var import_promises13 = require("fs/promises");
+var import_node_path21 = __toESM(require("path"), 1);
 async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   const log = opts.onProgress ?? (() => {
   });
   const result = { downloaded: 0, skipped: 0, failed: 0, ...opts.refresh ? { unchanged: 0 } : {} };
   const specByKey = new Map(specs.map((s) => [lockKey(s.styleId, s.assetId), s]));
   normalizeLockOutputPaths(lock, specs);
-  const cacheDir = opts.cacheDir === false ? null : import_node_path20.default.resolve(opts.cacheDir ?? import_node_path20.default.join(import_node_path20.default.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : import_node_path21.default.resolve(opts.cacheDir ?? import_node_path21.default.join(import_node_path21.default.dirname(lockPath), ".pixelkiln", "cache"));
   const pending = Object.entries(lock.entries).filter(([key, e]) => {
     if (e.provider !== provider.id || !specByKey.has(key)) return false;
     if (specByKey.get(key)?.mirror) return false;
@@ -12891,15 +13469,15 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
     if (spec && e.specHash === spec.specHash && e.outputs.length && !postprocessCurrent(e, spec)) {
       return Boolean(opts.force) || e.outputs.every((output) => {
         const file = resolveOutputPath(output.path, spec.root);
-        return (0, import_node_fs16.existsSync)(file) && sha256((0, import_node_fs16.readFileSync)(file)) === output.sha256;
+        return (0, import_node_fs17.existsSync)(file) && sha256((0, import_node_fs17.readFileSync)(file)) === output.sha256;
       });
     }
     if (!opts.repair) return false;
     if (e.outputs.length === 0 || !spec) return true;
     return e.outputs.some((output) => {
       const file = resolveOutputPath(output.path, spec.root);
-      if (!(0, import_node_fs16.existsSync)(file)) return true;
-      const current = sha256((0, import_node_fs16.readFileSync)(file));
+      if (!(0, import_node_fs17.existsSync)(file)) return true;
+      const current = sha256((0, import_node_fs17.readFileSync)(file));
       if (current === output.sha256) return false;
       return Boolean(opts.force) || (e.supersededOutputs ?? []).some((old) => old.sha256 === current);
     });
@@ -12982,21 +13560,21 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             if (!source.url) throw new Error(`no durable source URL to refresh ${source.role ?? "asset"} from`);
             fresh = await provider.download(source.url);
             if (recorded && sha256(fresh) === recordedRaw && !reapply) {
-              log(`  current ${import_node_path20.default.relative(process.cwd(), target)}`);
+              log(`  current ${import_node_path21.default.relative(process.cwd(), target)}`);
               outputs.push({ ...recorded, path: portableOutputPath(target, spec.root) });
               continue;
             }
           }
           let raw = null;
           let final = null;
-          if ((0, import_node_fs16.existsSync)(target)) {
+          if ((0, import_node_fs17.existsSync)(target)) {
             const currentHash = await sha256File(target);
             if (recorded && currentHash === recorded.sha256) {
               if (!fresh && !reapply) {
                 if (cacheDir) {
                   await cacheMedia(
                     cacheDir,
-                    await (0, import_promises12.readFile)(target),
+                    await (0, import_promises13.readFile)(target),
                     recorded.mediaType ?? MediaType.PNG,
                     recorded.sha256
                   );
@@ -13005,10 +13583,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
                 continue;
               }
               if (reapply && !fresh) {
-                if (!recorded.raw) raw = await (0, import_promises12.readFile)(target);
-                log(`  reapply ${import_node_path20.default.relative(process.cwd(), target)}`);
+                if (!recorded.raw) raw = await (0, import_promises13.readFile)(target);
+                log(`  reapply ${import_node_path21.default.relative(process.cwd(), target)}`);
               } else {
-                log(`  changed ${import_node_path20.default.relative(process.cwd(), target)} (upstream)`);
+                log(`  changed ${import_node_path21.default.relative(process.cwd(), target)} (upstream)`);
               }
             } else {
               const superseded = (entry.supersededOutputs ?? []).find(
@@ -13029,14 +13607,14 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
               }
               if (outgoing && cacheDir) {
                 try {
-                  const oldBytes = await (0, import_promises12.readFile)(target);
+                  const oldBytes = await (0, import_promises13.readFile)(target);
                   const oldMediaType = detectMediaType(oldBytes);
                   if (oldMediaType) await cacheMedia(cacheDir, oldBytes, oldMediaType, currentHash);
                 } catch {
                 }
               }
               log(
-                `  replace ${import_node_path20.default.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
+                `  replace ${import_node_path21.default.relative(process.cwd(), target)}` + (opts.force ? " (--force)" : " (previous tracked generation)")
               );
             }
           }
@@ -13045,7 +13623,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           } else if (!raw && recorded && cacheDir) {
             if (!reapply) final = await readCachedMedia(cacheDir, recorded.sha256, expectedMediaType);
             if (!final && recordedRaw) raw = await readCachedMedia(cacheDir, recordedRaw, expectedMediaType);
-            if (final || raw) log(`  cached  ${import_node_path20.default.relative(process.cwd(), target)}`);
+            if (final || raw) log(`  cached  ${import_node_path21.default.relative(process.cwd(), target)}`);
           }
           if (!final && !raw) {
             if (!source.url) {
@@ -13072,13 +13650,13 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             buf = processed.bytes;
             if (processed.changed) {
               rawHash = sha256(raw);
-              log(`  snapped ${import_node_path20.default.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
+              log(`  snapped ${import_node_path21.default.relative(process.cwd(), target)} to ${wanted.palette.colors.length} colours`);
             }
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await (0, import_promises12.mkdir)(import_node_path20.default.dirname(target), { recursive: true });
+          await (0, import_promises13.mkdir)(import_node_path21.default.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
-          await (0, import_promises12.writeFile)(tmp, buf);
+          await (0, import_promises13.writeFile)(tmp, buf);
           outputs.push({
             path: portableOutputPath(target, spec.root),
             sha256: sha256(buf),
@@ -13088,9 +13666,9 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           });
           upsert(lock, key, { outputs: mergeOutputs(entry.outputs, outputs) });
           await saveLock(lockPath, lock);
-          await (0, import_promises12.rename)(tmp, target);
+          await (0, import_promises13.rename)(tmp, target);
           wrote = true;
-          log(`  wrote   ${import_node_path20.default.relative(process.cwd(), target)}`);
+          log(`  wrote   ${import_node_path21.default.relative(process.cwd(), target)}`);
         }
         if (opts.refresh && !wrote) {
           if (rotated) {
@@ -13134,10 +13712,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = import_node_path20.default.join(cacheDir, cacheFileName(hash, mediaType));
-  if (!(0, import_node_fs16.existsSync)(file)) return null;
+  const file = import_node_path21.default.join(cacheDir, cacheFileName(hash, mediaType));
+  if (!(0, import_node_fs17.existsSync)(file)) return null;
   try {
-    const buf = await (0, import_promises12.readFile)(file);
+    const buf = await (0, import_promises13.readFile)(file);
     if (sha256(buf) !== hash) return null;
     validateMedia(buf, mediaType);
     return buf;
@@ -13148,17 +13726,17 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = import_node_path20.default.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = import_node_path21.default.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
-  await (0, import_promises12.mkdir)(cacheDir, { recursive: true });
+  await (0, import_promises13.mkdir)(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  await (0, import_promises12.writeFile)(tmp, buf);
+  await (0, import_promises13.writeFile)(tmp, buf);
   try {
-    await (0, import_promises12.rename)(tmp, file);
+    await (0, import_promises13.rename)(tmp, file);
   } catch (err) {
-    if (!(0, import_node_fs16.existsSync)(file)) throw err;
+    if (!(0, import_node_fs17.existsSync)(file)) throw err;
   } finally {
-    await (0, import_promises12.rm)(tmp, { force: true });
+    await (0, import_promises13.rm)(tmp, { force: true });
   }
 }
 function mergeOutputs(previous, current) {
@@ -13176,7 +13754,7 @@ async function pushTags(provider, specs, lock, opts = {}) {
   for (const [key, entry] of Object.entries(lock.entries)) {
     const spec = specByKey.get(key);
     if (!spec || entry.provider !== provider.id || !entry.objectId) continue;
-    if (entry.generator === "pixflux") continue;
+    if (entry.generator === "pixflux" || entry.generator === "vfx") continue;
     if (!provider.setTags) return tagged;
     try {
       await provider.setTags(entry.objectId, spec.tags, entry.generator);
@@ -13275,10 +13853,10 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
   }
   for (let i = 0; i < entry.outputs.length; i++) {
     const file = currentEntryOutputPath(entry, spec, i);
-    if (!(0, import_node_fs17.existsSync)(file)) continue;
+    if (!(0, import_node_fs18.existsSync)(file)) continue;
     if (await sha256File(file) !== entry.outputs[i].sha256 && !opts.force) {
       throw new OverwriteRefusedError(
-        `${import_node_path21.default.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
+        `${import_node_path22.default.relative(process.cwd(), file)} was changed after download; keep it with pixelkiln edit, or pass --force to replace it`,
         [file]
       );
     }
@@ -13330,11 +13908,11 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
 
 // src/pipeline/cache-health.ts
 async function inspectCaches(lock, lockPath, options = {}) {
-  if (options.prune && !(0, import_node_fs18.existsSync)(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${import_node_path22.default.resolve(lockPath)}`);
+  if (options.prune && !(0, import_node_fs19.existsSync)(lockPath)) {
+    throw new Error(`Refusing to prune without an existing lockfile at ${import_node_path23.default.resolve(lockPath)}`);
   }
-  const contentDir = import_node_path22.default.resolve(import_node_path22.default.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = import_node_path22.default.resolve(cachePathFor(lockPath));
+  const contentDir = import_node_path23.default.resolve(import_node_path23.default.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = import_node_path23.default.resolve(cachePathFor(lockPath));
   const referenced = referencedHashes(lock);
   let content = await inspectContentCache(contentDir, referenced);
   let remoteHashes = await inspectRemoteHashCache(remotePath);
@@ -13346,7 +13924,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await (0, import_promises13.rm)(import_node_path22.default.join(contentDir, name), { force: true });
+        await (0, import_promises14.rm)(import_node_path23.default.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -13355,7 +13933,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
       await saveCache(remotePath, { version: 1, hashes: {} });
       removed.resetRemoteHashCache = true;
     } else if (remoteHashes.invalidIds.length) {
-      const cache = parseCache(JSON.parse(await (0, import_promises13.readFile)(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await (0, import_promises14.readFile)(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -13373,7 +13951,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
 async function inspectContentCache(contentDir, referenced) {
   const report = {
     path: contentDir,
-    exists: (0, import_node_fs18.existsSync)(contentDir),
+    exists: (0, import_node_fs19.existsSync)(contentDir),
     files: 0,
     bytes: 0,
     valid: 0,
@@ -13387,19 +13965,19 @@ async function inspectContentCache(contentDir, referenced) {
     return report;
   }
   const present = /* @__PURE__ */ new Set();
-  const entries = await (0, import_promises13.readdir)(contentDir, { withFileTypes: true });
+  const entries = await (0, import_promises14.readdir)(contentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isFile()) {
       report.invalid.push({ name: entry.name, reason: "not a regular file" });
       continue;
     }
     report.files++;
-    const file = import_node_path22.default.join(contentDir, entry.name);
+    const file = import_node_path23.default.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await (0, import_promises13.readFile)(file);
+      bytes = await (0, import_promises14.readFile)(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -13437,7 +14015,7 @@ async function inspectContentCache(contentDir, referenced) {
 async function inspectRemoteHashCache(remotePath) {
   const report = {
     path: remotePath,
-    exists: (0, import_node_fs18.existsSync)(remotePath),
+    exists: (0, import_node_fs19.existsSync)(remotePath),
     entries: 0,
     valid: 0,
     invalidIds: [],
@@ -13446,7 +14024,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await (0, import_promises13.readFile)(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await (0, import_promises14.readFile)(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -13461,20 +14039,20 @@ async function inspectRemoteHashCache(remotePath) {
 }
 
 // src/pipeline/pack.ts
-var import_node_fs19 = require("fs");
-var import_node_path23 = __toESM(require("path"), 1);
+var import_node_fs20 = require("fs");
+var import_node_path24 = __toESM(require("path"), 1);
 var DEFAULT_FRAME_SET_FPS = 12;
 function resolvePackInputs(raw, inputsFilePath) {
   if (!Array.isArray(raw) || !raw.length) {
     throw new Error("--inputs must be a non-empty JSON array of { id, path }");
   }
-  const baseDir = import_node_path23.default.dirname(import_node_path23.default.resolve(inputsFilePath));
+  const baseDir = import_node_path24.default.dirname(import_node_path24.default.resolve(inputsFilePath));
   return raw.map((entry, i) => {
     const e = entry;
     if (typeof e.id !== "string" || typeof e.path !== "string") {
       throw new Error(`--inputs[${i}] needs string "id" and "path"`);
     }
-    return { id: e.id, path: import_node_path23.default.resolve(baseDir, e.path) };
+    return { id: e.id, path: import_node_path24.default.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -13495,7 +14073,7 @@ function packSprites(inputs, options = {}) {
   for (const input of ordered) {
     let sourceHash = null;
     try {
-      const bytes = (0, import_node_fs19.readFileSync)(input.path);
+      const bytes = (0, import_node_fs20.readFileSync)(input.path);
       sourceHash = sha256(bytes);
       const png = decodePng(bytes);
       sprites.push({ id: input.id, width: png.width, height: png.height, pixels: png.pixels });
@@ -13558,7 +14136,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     }
     const inputs2 = Object.entries(options.sourceOverrides).map(([id, source]) => ({
       id,
-      path: import_node_path23.default.resolve(source)
+      path: import_node_path24.default.resolve(source)
     }));
     if (!inputs2.length) throw new Error(`No approved quality outputs for style "${styleId}".`);
     const packed2 = packSprites(inputs2, options);
@@ -13582,7 +14160,7 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
     let outputs = resolveEntryOutputs(entry, id, manifestDir);
     const source = sources[id];
     if (source && outputs.length <= 1) {
-      inputs.push({ id, path: import_node_path23.default.resolve(manifestDir, source) });
+      inputs.push({ id, path: import_node_path24.default.resolve(manifestDir, source) });
       continue;
     }
     if (source && sourceIsStem(source, entry, manifestDir)) {
@@ -13611,12 +14189,13 @@ function packStyle(lock, styleId, manifestDir, options = {}) {
         id,
         kind: isFrames ? "frames" : "members",
         ...fps ? { fps } : {},
+        ...isFrames && frameSetLoop(entry) === false ? { loop: false } : {},
         frames: selected.map((output) => output.id)
       });
     }
   }
   for (const [id, source] of Object.entries(sources)) {
-    if (!locked.has(id)) inputs.push({ id, path: import_node_path23.default.resolve(manifestDir, source) });
+    if (!locked.has(id)) inputs.push({ id, path: import_node_path24.default.resolve(manifestDir, source) });
   }
   if (!inputs.length) {
     throw new Error(`No readable sprites for style "${styleId}"; ${noOutput.length} skipped.`);
@@ -13653,7 +14232,7 @@ function mountSprites(placements, options) {
   for (const p of placements) {
     let sourceHash = null;
     try {
-      const bytes = (0, import_node_fs19.readFileSync)(p.path);
+      const bytes = (0, import_node_fs20.readFileSync)(p.path);
       sourceHash = sha256(bytes);
       const png = decodePng(bytes);
       if (png.width > cellWidth || png.height > cellHeight) {
@@ -13724,7 +14303,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     const source = sources[id];
     const entry = lock.entries[`${styleId}/${id}`];
     if (source && !(entry && sourceIsStem(source, entry, manifestDir))) {
-      placements.push({ id, path: import_node_path23.default.resolve(manifestDir, source), cell });
+      placements.push({ id, path: import_node_path24.default.resolve(manifestDir, source), cell });
       continue;
     }
     if (source && entry) {
@@ -13757,7 +14336,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
       `Nothing to mount for style "${styleId}": ${ids.length} asset(s) declare a cell, but none has generated output or a \`source\`. Run \`pixelkiln gen --style ${styleId}\`, or point each at a file.${detail}`
     );
   }
-  const basePng = mount.base ? (0, import_node_fs19.readFileSync)(import_node_path23.default.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? (0, import_node_fs20.readFileSync)(import_node_path24.default.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -13767,7 +14346,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: import_node_path23.default.resolve(manifestDir, mount.base),
+      path: import_node_path24.default.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -14149,7 +14728,7 @@ function renderGodotSpriteFrames(atlas, opts) {
     );
   };
   for (const set of atlas.sets ?? []) {
-    if (set.kind === "frames") animation(set.id, set.frames, set.fps ?? GODOT_DEFAULT_SPEED, true);
+    if (set.kind === "frames") animation(set.id, set.frames, set.fps ?? GODOT_DEFAULT_SPEED, set.loop ?? true);
     else for (const id of set.frames) animation(id, [id], GODOT_DEFAULT_SPEED, false);
   }
   for (const frame of atlas.frames) {
@@ -14404,6 +14983,8 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
       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 lastGeneration = previousEntry?.status === "downloaded" ? previousEntry : previousEntry?.history?.[0];
+      const lastGenerationMetadata = lastGeneration?.providerMetadata?.[provider.id];
       const parentOutputs = spec.character?.kind === "outfit" && parentEntry ? parentEntry.outputs.map((output, index) => ({
         path: currentEntryOutputPath(parentEntry, spec.character.parentSpec, index),
         role: output.role
@@ -14416,6 +14997,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
         ...anchorEntry?.objectId ? { styleObjectId: anchorEntry.objectId } : {},
         ...parentOutputs ? { parentOutputs } : {},
         ...replacedMetadata ? { replacedMetadata } : {},
+        ...lastGenerationMetadata ? { lastGenerationMetadata } : {},
         ...previousMetadata ? { previousMetadata } : {},
         checkpoint: async (checkpoint) => {
           if (!checkpoint.jobId) throw new Error("Provider checkpoint returned an empty job id");
@@ -14578,9 +15160,9 @@ async function poll(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/doctor.ts
-var import_node_fs20 = require("fs");
-var import_promises14 = require("fs/promises");
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_fs21 = require("fs");
+var import_promises15 = require("fs/promises");
+var import_node_path25 = __toESM(require("path"), 1);
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message6) => checks.push({ id, level, message: message6 });
@@ -14591,14 +15173,14 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   );
   add("lock", "ok", `${Object.keys(lock.entries).length} valid v2 lock entr(ies)`);
   const dirs = [...new Set(specs.flatMap((spec) => [
-    import_node_path24.default.dirname(spec.outFile),
-    ...spec.quality ? [import_node_path24.default.dirname(spec.quality.outFile)] : []
+    import_node_path25.default.dirname(spec.outFile),
+    ...spec.quality ? [import_node_path25.default.dirname(spec.quality.outFile)] : []
   ]))];
   const unwritable = [];
   for (const dir of dirs) {
     const ancestor = await nearestExistingDirectory(dir);
     try {
-      await (0, import_promises14.access)(ancestor, import_node_fs20.constants.W_OK);
+      await (0, import_promises15.access)(ancestor, import_node_fs21.constants.W_OK);
     } catch {
       unwritable.push(dir);
     }
@@ -14615,7 +15197,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     for (let index = 0; index < entry.outputs.length; index++) {
       const output = entry.outputs[index];
       const spec = specByKey.get(key);
-      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, import_node_path24.default.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, import_node_path25.default.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -14630,7 +15212,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   } else {
     add("lock-outputs", "ok", `${outputOwners.size} recorded output path(s) are uniquely owned`);
   }
-  const cacheDir = import_node_path24.default.join(import_node_path24.default.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = import_node_path25.default.join(import_node_path25.default.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -14646,11 +15228,11 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     const hasSource = Boolean(entry.sourceUrl || entry.sourceUrls?.length);
     let hasCache = false;
     for (const output of entry.outputs) {
-      const cached = import_node_path24.default.join(
+      const cached = import_node_path25.default.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
-      if ((0, import_node_fs20.existsSync)(cached) && await sha256File(cached) === output.sha256) {
+      if ((0, import_node_fs21.existsSync)(cached) && await sha256File(cached) === output.sha256) {
         hasCache = true;
         break;
       }
@@ -14743,19 +15325,19 @@ async function nearestExistingDirectory(start) {
   let current = start;
   for (; ; ) {
     try {
-      if ((await (0, import_promises14.stat)(current)).isDirectory()) return current;
+      if ((await (0, import_promises15.stat)(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = import_node_path24.default.dirname(current);
+    const parent = import_node_path25.default.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
 }
 
 // src/pipeline/adopt.ts
-var import_node_fs21 = require("fs");
-var import_promises15 = require("fs/promises");
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_fs22 = require("fs");
+var import_promises16 = require("fs/promises");
+var import_node_path26 = __toESM(require("path"), 1);
 async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const log = opts.onProgress ?? (() => {
   });
@@ -14766,11 +15348,11 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const localByHash = /* @__PURE__ */ new Map();
   const unmatchedLocal = [];
   for (const spec of specs) {
-    if (!(0, import_node_fs21.existsSync)(spec.outFile)) {
+    if (!(0, import_node_fs22.existsSync)(spec.outFile)) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
-    const bytes = await (0, import_promises15.readFile)(spec.outFile);
+    const bytes = await (0, import_promises16.readFile)(spec.outFile);
     try {
       decodePng(bytes);
     } catch (err) {
@@ -14888,13 +15470,13 @@ async function tagAdopted(provider, specs, lock, opts = {}) {
 }
 
 // src/pick/server.ts
-var import_node_fs23 = require("fs");
-var import_promises18 = require("fs/promises");
+var import_node_fs24 = require("fs");
+var import_promises19 = require("fs/promises");
 
 // src/pipeline/init.ts
-var import_promises16 = require("fs/promises");
-var import_node_fs22 = require("fs");
-var import_node_path26 = __toESM(require("path"), 1);
+var import_promises17 = require("fs/promises");
+var import_node_fs23 = require("fs");
+var import_node_path27 = __toESM(require("path"), 1);
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -14907,8 +15489,8 @@ function slugify(value) {
 }
 async function walk(dir, exclude) {
   const out = [];
-  for (const entry of await (0, import_promises16.readdir)(dir, { withFileTypes: true })) {
-    const full = import_node_path26.default.join(dir, entry.name);
+  for (const entry of await (0, import_promises17.readdir)(dir, { withFileTypes: true })) {
+    const full = import_node_path27.default.join(dir, entry.name);
     if (exclude.some((x) => full.includes(x))) continue;
     if (entry.isDirectory()) out.push(...await walk(full, exclude));
     else if (entry.name.toLowerCase().endsWith(".png")) out.push(full);
@@ -14922,14 +15504,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await (0, import_promises16.readFile)(file));
+    const size = pngSize(await (0, import_promises17.readFile)(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = import_node_path26.default.relative(root, file);
-    const category = import_node_path26.default.dirname(rel) === "." ? "" : import_node_path26.default.dirname(rel);
-    let id = slugify(import_node_path26.default.basename(rel));
+    const rel = import_node_path27.default.relative(root, file);
+    const category = import_node_path27.default.dirname(rel) === "." ? "" : import_node_path27.default.dirname(rel);
+    let id = slugify(import_node_path27.default.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -15393,7 +15975,7 @@ document.getElementById('submit').onclick = async () => {
 
 // src/pick/review-server.ts
 var import_node_http = require("http");
-var import_promises17 = require("fs/promises");
+var import_promises18 = require("fs/promises");
 function serveReviewPage(opts) {
   const log = opts.onProgress ?? (() => {
   });
@@ -15402,7 +15984,7 @@ function serveReviewPage(opts) {
       if (req.method === "GET" && req.url && opts.assets?.has(req.url)) {
         try {
           const asset = opts.assets.get(req.url);
-          const bytes = await (0, import_promises17.readFile)(asset.path);
+          const bytes = await (0, import_promises18.readFile)(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -15478,13 +16060,13 @@ async function currentArt(entry, spec) {
   const previous = primaryOutput({ ...entry, outputs: entry.supersededOutputs });
   if (!previous) return null;
   const file = resolveOutputPath(previous.path, spec.root);
-  if (!(0, import_node_fs23.existsSync)(file)) return null;
+  if (!(0, import_node_fs24.existsSync)(file)) return null;
   const contentType = previous.mediaType ?? mediaTypeFromExtension(file);
   if (!contentType) return null;
   let width = entry.width;
   let height = entry.height;
   if (contentType === "image/png") {
-    const size = pngSize(await (0, import_promises18.readFile)(file));
+    const size = pngSize(await (0, import_promises19.readFile)(file));
     if (size) ({ width, height } = size);
   }
   return { path: file, contentType, width, height };
@@ -15492,7 +16074,7 @@ async function currentArt(entry, spec) {
 async function cachedFrame(url) {
   if (!url.startsWith("file://")) return null;
   const file = url.slice("file://".length);
-  const contentType = mediaTypeFromExtension(file) ?? detectMediaType(await (0, import_promises18.readFile)(file).catch(() => Buffer.alloc(0))) ?? "application/octet-stream";
+  const contentType = mediaTypeFromExtension(file) ?? detectMediaType(await (0, import_promises19.readFile)(file).catch(() => Buffer.alloc(0))) ?? "application/octet-stream";
   return { path: file, contentType };
 }
 async function prepareReview(provider, lock, opts = {}) {
@@ -15674,14 +16256,14 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 
 // src/gallery/snapshot.ts
 var import_node_crypto7 = require("crypto");
-var import_node_fs29 = require("fs");
-var import_promises26 = require("fs/promises");
-var import_node_path34 = __toESM(require("path"), 1);
+var import_node_fs30 = require("fs");
+var import_promises27 = require("fs/promises");
+var import_node_path35 = __toESM(require("path"), 1);
 
 // src/workspace.ts
-var import_promises19 = require("fs/promises");
-var import_node_fs24 = require("fs");
-var import_node_path27 = __toESM(require("path"), 1);
+var import_promises20 = require("fs/promises");
+var import_node_fs25 = require("fs");
+var import_node_path28 = __toESM(require("path"), 1);
 var import_zod7 = require("zod");
 var WorkspaceProjectSchema = import_zod7.z.object({
   id: import_zod7.z.string().min(1),
@@ -15706,10 +16288,10 @@ ${parsed.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".")}: ${i.message
   );
 }
 async function loadWorkspace(workspacePath) {
-  if (!(0, import_node_fs24.existsSync)(workspacePath)) return { version: 1, projects: [] };
+  if (!(0, import_node_fs25.existsSync)(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await (0, import_promises19.readFile)(workspacePath, "utf8"));
+    raw = JSON.parse(await (0, import_promises20.readFile)(workspacePath, "utf8"));
   } catch (err) {
     throw new ProjectError(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -15723,22 +16305,22 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await (0, import_promises19.mkdir)(import_node_path27.default.dirname(import_node_path27.default.resolve(workspacePath)), { recursive: true });
+  await (0, import_promises20.mkdir)(import_node_path28.default.dirname(import_node_path28.default.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises19.writeFile)(tmp, JSON.stringify(sorted, null, 2) + "\n");
-    await (0, import_promises19.rename)(tmp, workspacePath);
+    await (0, import_promises20.writeFile)(tmp, JSON.stringify(sorted, null, 2) + "\n");
+    await (0, import_promises20.rename)(tmp, workspacePath);
   } finally {
-    await (0, import_promises19.rm)(tmp, { force: true });
+    await (0, import_promises20.rm)(tmp, { force: true });
   }
 }
 function toPortablePath(dir, absolute) {
-  return import_node_path27.default.relative(dir, absolute).split(import_node_path27.default.sep).join("/");
+  return import_node_path28.default.relative(dir, absolute).split(import_node_path28.default.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: import_node_path27.default.resolve(dir, project.manifest.split("/").join(import_node_path27.default.sep)),
-    lockPath: import_node_path27.default.resolve(dir, project.lock.split("/").join(import_node_path27.default.sep))
+    manifestPath: import_node_path28.default.resolve(dir, project.manifest.split("/").join(import_node_path28.default.sep)),
+    lockPath: import_node_path28.default.resolve(dir, project.lock.split("/").join(import_node_path28.default.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -15751,21 +16333,21 @@ function validateWorkspace(ws, dir) {
     const { manifestPath, lockPath } = resolveProject(dir, project);
     lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
     manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
-    if (import_node_path27.default.isAbsolute(project.manifest) || import_node_path27.default.isAbsolute(project.lock)) {
+    if (import_node_path28.default.isAbsolute(project.manifest) || import_node_path28.default.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
         message: `project "${project.id}" stores an absolute path; the catalog will not resolve correctly if this tree is cloned or moved elsewhere`
       });
     }
-    if (!(0, import_node_fs24.existsSync)(manifestPath)) {
+    if (!(0, import_node_fs25.existsSync)(manifestPath)) {
       diagnostics.push({
         id: "missing-manifest",
         level: "error",
         message: `project "${project.id}" manifest not found: ${manifestPath}`
       });
     }
-    if (!(0, import_node_fs24.existsSync)(lockPath)) {
+    if (!(0, import_node_fs25.existsSync)(lockPath)) {
       diagnostics.push({
         id: "missing-lock",
         level: "error",
@@ -15812,16 +16394,16 @@ function validateWorkspace(ws, dir) {
 }
 
 // src/gallery/edit.ts
-var import_promises25 = require("fs/promises");
-var import_node_path33 = __toESM(require("path"), 1);
+var import_promises26 = require("fs/promises");
+var import_node_path34 = __toESM(require("path"), 1);
 var import_zod13 = require("zod");
 
 // src/manifest-edit.ts
-var import_promises20 = require("fs/promises");
-var import_node_path28 = __toESM(require("path"), 1);
+var import_promises21 = require("fs/promises");
+var import_node_path29 = __toESM(require("path"), 1);
 var import_zod8 = require("zod");
 var HexSha = import_zod8.z.string().regex(/^[0-9a-f]{64}$/);
-var ProjectFileSchema = import_zod8.z.string().min(1).refine((file) => !import_node_path28.default.isAbsolute(file) && !file.split(/[\\/]/).includes(".."), "must be a path inside the project");
+var ProjectFileSchema = import_zod8.z.string().min(1).refine((file) => !import_node_path29.default.isAbsolute(file) && !file.split(/[\\/]/).includes(".."), "must be a path inside the project");
 var AssetPatchSchema = import_zod8.z.object({
   prompt: import_zod8.z.string().optional(),
   /** Per-style override for the style being viewed; null removes it. */
@@ -16240,8 +16822,8 @@ function applyEdit(raw, edit) {
   }
 }
 async function withCandidate(manifestPath, edit, use, unchanged) {
-  const absolute = import_node_path28.default.resolve(manifestPath);
-  const original = await (0, import_promises20.readFile)(absolute, "utf8");
+  const absolute = import_node_path29.default.resolve(manifestPath);
+  const original = await (0, import_promises21.readFile)(absolute, "utf8");
   if (sha256(original) !== edit.expectedSha256) throw new ManifestDriftError(absolute);
   let raw;
   try {
@@ -16254,12 +16836,12 @@ async function withCandidate(manifestPath, edit, use, unchanged) {
   applyEdit(raw, edit);
   const next = serializeLike(original, raw);
   if (next === original) return unchanged(absolute, original);
-  const tmp = import_node_path28.default.join(
-    import_node_path28.default.dirname(absolute),
-    `.${import_node_path28.default.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
+  const tmp = import_node_path29.default.join(
+    import_node_path29.default.dirname(absolute),
+    `.${import_node_path29.default.basename(absolute)}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`
   );
   try {
-    await (0, import_promises20.writeFile)(tmp, next);
+    await (0, import_promises21.writeFile)(tmp, next);
     let specs;
     try {
       specs = await resolveSpecs(await loadManifest(tmp));
@@ -16269,7 +16851,7 @@ async function withCandidate(manifestPath, edit, use, unchanged) {
     }
     return await use({ absolute, original, next, tmp, specs });
   } finally {
-    await (0, import_promises20.rm)(tmp, { force: true });
+    await (0, import_promises21.rm)(tmp, { force: true });
   }
 }
 async function applyManifestEdit(manifestPath, edit) {
@@ -16277,7 +16859,7 @@ async function applyManifestEdit(manifestPath, edit) {
     manifestPath,
     edit,
     async ({ absolute, next, tmp }) => {
-      await (0, import_promises20.rename)(tmp, absolute);
+      await (0, import_promises21.rename)(tmp, absolute);
       return { manifestPath: absolute, sha256: sha256(next), changed: true };
     },
     (absolute, original) => ({ manifestPath: absolute, sha256: sha256(original), changed: false })
@@ -16285,18 +16867,18 @@ async function applyManifestEdit(manifestPath, edit) {
 }
 
 // src/pipeline/hand-edit.ts
-var import_node_fs25 = require("fs");
-var import_promises21 = require("fs/promises");
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_fs26 = require("fs");
+var import_promises22 = require("fs/promises");
+var import_node_path30 = __toESM(require("path"), 1);
 var import_zod9 = require("zod");
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
-  const outDir = import_node_path29.default.resolve(loaded.root, style?.outDir ?? ".");
-  const relative = import_node_path29.default.relative(outDir, spec.outFile);
-  const inside = relative && !relative.startsWith("..") && !import_node_path29.default.isAbsolute(relative);
-  const file = inside ? relative : import_node_path29.default.basename(spec.outFile);
-  return import_node_path29.default.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
+  const outDir = import_node_path30.default.resolve(loaded.root, style?.outDir ?? ".");
+  const relative = import_node_path30.default.relative(outDir, spec.outFile);
+  const inside = relative && !relative.startsWith("..") && !import_node_path30.default.isAbsolute(relative);
+  const file = inside ? relative : import_node_path30.default.basename(spec.outFile);
+  return import_node_path30.default.join(outDir, HAND_EDIT_DIR, file.replace(/\.gif$/i, ".png"));
 }
 function handEditBases(spec, lock) {
   const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
@@ -16309,10 +16891,10 @@ function handEditBases(spec, lock) {
     }));
     if (members.some((member) => member.mediaType && member.mediaType !== "image/png")) return null;
     if (entry.outputs.length === 1 && !primaryOutput(entry)) return null;
-    if (!members.every((member) => (0, import_node_fs25.existsSync)(member.path))) return null;
+    if (!members.every((member) => (0, import_node_fs26.existsSync)(member.path))) return null;
     return members.map(({ role, path: file }) => ({ role, path: file }));
   }
-  return (0, import_node_fs25.existsSync)(spec.outFile) ? [{ role: null, path: spec.outFile }] : null;
+  return (0, import_node_fs26.existsSync)(spec.outFile) ? [{ role: null, path: spec.outFile }] : null;
 }
 function handEditBase(spec, lock) {
   const bases = handEditBases(spec, lock);
@@ -16342,19 +16924,19 @@ async function startHandEdit(loaded, lock, spec, opts = {}) {
       `${spec.styleId}/${spec.assetId} declares ${spec.source}, one committed file placed for the whole set; clear that source (pixelkiln edit detach) to hand-edit the members one by one`
     );
   }
-  const existing = spec.source ? import_node_path29.default.resolve(loaded.root, spec.source) : null;
+  const existing = spec.source ? import_node_path30.default.resolve(loaded.root, spec.source) : null;
   const editPath = existing ?? handEditPath(loaded, spec);
   const members = handEditMembers(loaded, spec, lock, editPath);
   let created = false;
   for (const member of members) {
-    if ((0, import_node_fs25.existsSync)(member.path)) continue;
+    if ((0, import_node_fs26.existsSync)(member.path)) continue;
     if (!member.base) {
       throw new ManifestEditError(
         `${spec.styleId}/${spec.assetId} has no generated PNG on disk to start from; generate or restore it first`
       );
     }
-    await (0, import_promises21.mkdir)(import_node_path29.default.dirname(member.path), { recursive: true });
-    await (0, import_promises21.copyFile)(member.base, member.path);
+    await (0, import_promises22.mkdir)(import_node_path30.default.dirname(member.path), { recursive: true });
+    await (0, import_promises22.copyFile)(member.base, member.path);
     created = true;
   }
   const source = portableOutputPath(editPath, loaded.root);
@@ -16432,7 +17014,7 @@ function handEditProjectPath(editPath) {
 async function readHandEditCompanion(editPath) {
   let text;
   try {
-    text = await (0, import_promises21.readFile)(handEditCompanionPath(editPath), "utf8");
+    text = await (0, import_promises22.readFile)(handEditCompanionPath(editPath), "utf8");
   } catch {
     return null;
   }
@@ -16475,7 +17057,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     }
   });
   const bases = handEditBases(spec, lock);
-  const expectedSize = bases?.[0] ? decodePng(await (0, import_promises21.readFile)(bases[0].path)) : { width: spec.width, height: spec.height };
+  const expectedSize = bases?.[0] ? decodePng(await (0, import_promises22.readFile)(bases[0].path)) : { width: spec.width, height: spec.height };
   for (const [index, image] of decoded.entries()) {
     if (image.width !== expectedSize.width || image.height !== expectedSize.height) {
       const which = memberSet ? `member ${incoming[index].role ?? index}` : "the edit";
@@ -16491,7 +17073,7 @@ async function saveHandEdit(loaded, lock, spec, input) {
     editor: input.editor,
     protocol: input.protocol,
     savedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
-    project: projectPath ? import_node_path29.default.basename(projectPath) : null,
+    project: projectPath ? import_node_path30.default.basename(projectPath) : null,
     outputs: incoming.map((frame, index) => ({
       role: frame.role,
       basedOn: basedOnHash(entry, index),
@@ -16521,10 +17103,10 @@ function basedOnHash(entry, index) {
 async function replaceFile(file, bytes) {
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises21.writeFile)(tmp, bytes);
-    await (0, import_promises21.rename)(tmp, file);
+    await (0, import_promises22.writeFile)(tmp, bytes);
+    await (0, import_promises22.rename)(tmp, file);
   } finally {
-    await (0, import_promises21.rm)(tmp, { force: true });
+    await (0, import_promises22.rm)(tmp, { force: true });
   }
 }
 function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
@@ -16533,9 +17115,9 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
 }
 
 // src/gallery/upload.ts
-var import_node_fs26 = require("fs");
-var import_promises22 = require("fs/promises");
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_fs27 = require("fs");
+var import_promises23 = require("fs/promises");
+var import_node_path31 = __toESM(require("path"), 1);
 var import_zod10 = require("zod");
 var MAX_UPLOAD_BYTES = 8 * 1024 * 1024;
 var UploadImageSchema = import_zod10.z.object({
@@ -16548,12 +17130,12 @@ var UploadImageSchema = import_zod10.z.object({
   overwrite: import_zod10.z.boolean().optional()
 }).strict();
 async function saveProjectImage(root, request) {
-  const file = import_node_path30.default.resolve(root, request.path);
-  const relative = import_node_path30.default.relative(root, file);
-  if (relative.startsWith("..") || import_node_path30.default.isAbsolute(relative)) {
+  const file = import_node_path31.default.resolve(root, request.path);
+  const relative = import_node_path31.default.relative(root, file);
+  if (relative.startsWith("..") || import_node_path31.default.isAbsolute(relative)) {
     throw new ManifestEditError("an upload must stay inside the project");
   }
-  const extension = import_node_path30.default.extname(file).toLowerCase();
+  const extension = import_node_path31.default.extname(file).toLowerCase();
   const expected = extension === ".png" ? "png" : extension === ".jpg" || extension === ".jpeg" ? "jpeg" : null;
   if (!expected) throw new ManifestEditError("an upload must be a .png, .jpg, or .jpeg path");
   const bytes = Buffer.from(request.base64, "base64");
@@ -16565,18 +17147,18 @@ async function saveProjectImage(root, request) {
   if (metadata.format !== expected) {
     throw new ManifestEditError(`the upload is a ${metadata.format.toUpperCase()}; name it ${metadata.format === "png" ? ".png" : ".jpg"}`);
   }
-  if ((0, import_node_fs26.existsSync)(file) && !request.overwrite) {
-    throw new ManifestEditError(`${relative.split(import_node_path30.default.sep).join("/")} already exists; choose another name, or replace it`);
+  if ((0, import_node_fs27.existsSync)(file) && !request.overwrite) {
+    throw new ManifestEditError(`${relative.split(import_node_path31.default.sep).join("/")} already exists; choose another name, or replace it`);
   }
-  await (0, import_promises22.mkdir)(import_node_path30.default.dirname(file), { recursive: true });
-  await (0, import_promises22.writeFile)(file, bytes);
-  return relative.split(import_node_path30.default.sep).join("/");
+  await (0, import_promises23.mkdir)(import_node_path31.default.dirname(file), { recursive: true });
+  await (0, import_promises23.writeFile)(file, bytes);
+  return relative.split(import_node_path31.default.sep).join("/");
 }
 
 // src/gallery/image-revision.ts
-var import_node_fs27 = require("fs");
-var import_promises23 = require("fs/promises");
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_fs28 = require("fs");
+var import_promises24 = require("fs/promises");
+var import_node_path32 = __toESM(require("path"), 1);
 var import_zod11 = require("zod");
 var InpaintRevisionRequestSchema = import_zod11.z.object({
   action: import_zod11.z.literal("create-inpaint-revision"),
@@ -16595,15 +17177,15 @@ var InpaintRevisionRequestSchema = import_zod11.z.object({
   overwrite: import_zod11.z.boolean().optional()
 }).strict();
 async function createInpaintRevision(manifestPath, request) {
-  const root = import_node_path31.default.dirname(import_node_path31.default.resolve(manifestPath));
-  if (import_node_path31.default.extname(request.maskPath).toLowerCase() !== ".png") {
+  const root = import_node_path32.default.dirname(import_node_path32.default.resolve(manifestPath));
+  if (import_node_path32.default.extname(request.maskPath).toLowerCase() !== ".png") {
     throw new ManifestEditError("the mask must be a .png path inside the project");
   }
   const bytes = Buffer.from(request.maskBase64, "base64");
   const metadata = imageMetadata(bytes);
   if (!metadata || metadata.format !== "png") throw new ManifestEditError("the mask is not a readable PNG");
-  const file = import_node_path31.default.resolve(root, request.maskPath);
-  const previous = (0, import_node_fs27.existsSync)(file) ? await (0, import_promises23.readFile)(file) : null;
+  const file = import_node_path32.default.resolve(root, request.maskPath);
+  const previous = (0, import_node_fs28.existsSync)(file) ? await (0, import_promises24.readFile)(file) : null;
   const mask = await saveProjectImage(root, {
     action: "upload-image",
     path: request.maskPath,
@@ -16622,17 +17204,17 @@ async function createInpaintRevision(manifestPath, request) {
       }
     });
   } catch (error) {
-    if (previous) await (0, import_promises23.writeFile)(file, previous);
-    else await (0, import_promises23.rm)(file, { force: true });
+    if (previous) await (0, import_promises24.writeFile)(file, previous);
+    else await (0, import_promises24.rm)(file, { force: true });
     throw error;
   }
   return mask;
 }
 
 // src/gallery/skeleton.ts
-var import_node_fs28 = require("fs");
-var import_promises24 = require("fs/promises");
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_fs29 = require("fs");
+var import_promises25 = require("fs/promises");
+var import_node_path33 = __toESM(require("path"), 1);
 var import_zod12 = require("zod");
 var SkeletonEstimateRequestSchema = import_zod12.z.object({
   project: import_zod12.z.string().min(1).optional(),
@@ -16670,21 +17252,21 @@ var SkeletonKeypointsUpdateSchema = import_zod12.z.object({
   set: SkeletonSetSchema
 }).strict();
 async function createSkeletonAnimation(manifestPath, request) {
-  const root = import_node_path32.default.dirname(import_node_path32.default.resolve(manifestPath));
-  const file = import_node_path32.default.resolve(root, request.keypointsFile);
-  const relative = import_node_path32.default.relative(root, file);
-  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || import_node_path32.default.isAbsolute(relative)) {
+  const root = import_node_path33.default.dirname(import_node_path33.default.resolve(manifestPath));
+  const file = import_node_path33.default.resolve(root, request.keypointsFile);
+  const relative = import_node_path33.default.relative(root, file);
+  if (!request.keypointsFile.endsWith(".json") || relative.startsWith("..") || import_node_path33.default.isAbsolute(relative)) {
     throw new ManifestEditError("the keypoints file must be a .json path inside the project");
   }
-  const existed = (0, import_node_fs28.existsSync)(file);
+  const existed = (0, import_node_fs29.existsSync)(file);
   let previous = null;
   if (request.set) {
     if (existed && !request.overwrite) {
       throw new ManifestEditError(`${request.keypointsFile} already exists; choose another path, or replace it`);
     }
-    if (existed) previous = await (0, import_promises24.readFile)(file);
-    await (0, import_promises24.mkdir)(import_node_path32.default.dirname(file), { recursive: true });
-    await (0, import_promises24.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
+    if (existed) previous = await (0, import_promises25.readFile)(file);
+    await (0, import_promises25.mkdir)(import_node_path33.default.dirname(file), { recursive: true });
+    await (0, import_promises25.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
   } else if (!existed) {
     throw new ManifestEditError(`${request.keypointsFile} does not exist; paste poses or estimate them from the sprite`);
   }
@@ -16699,7 +17281,7 @@ async function createSkeletonAnimation(manifestPath, request) {
         revision: {
           mode: "animate-skeleton",
           from: request.from,
-          keypointsFile: relative.split(import_node_path32.default.sep).join("/"),
+          keypointsFile: relative.split(import_node_path33.default.sep).join("/"),
           direction: request.direction,
           ...request.description ? { description: request.description } : {},
           ...request.skeletonTemplate ? { skeletonTemplate: request.skeletonTemplate } : {}
@@ -16708,8 +17290,8 @@ async function createSkeletonAnimation(manifestPath, request) {
     });
   } catch (error) {
     if (request.set) {
-      if (previous) await (0, import_promises24.writeFile)(file, previous);
-      else await (0, import_promises24.rm)(file, { force: true });
+      if (previous) await (0, import_promises25.writeFile)(file, previous);
+      else await (0, import_promises25.rm)(file, { force: true });
     }
     throw error;
   }
@@ -16720,19 +17302,19 @@ async function updateSkeletonKeypoints(ctx, request) {
   if (!spec) throw new ManifestEditError(`"${key}" is not declared by the manifest`);
   const file = spec.revision?.mode === "animate-skeleton" ? spec.revision.keypointsFile : void 0;
   if (!file) throw new ManifestEditError(`${key} is not an animate-skeleton revision`);
-  const relative = import_node_path32.default.relative(ctx.loaded.root, file);
-  if (relative.startsWith("..") || import_node_path32.default.isAbsolute(relative)) {
+  const relative = import_node_path33.default.relative(ctx.loaded.root, file);
+  if (relative.startsWith("..") || import_node_path33.default.isAbsolute(relative)) {
     throw new ManifestEditError(`${key}'s keypoints file is outside the project; edit it by hand`);
   }
-  const current = (0, import_node_fs28.existsSync)(file) ? sha256(await (0, import_promises24.readFile)(file)) : null;
+  const current = (0, import_node_fs29.existsSync)(file) ? sha256(await (0, import_promises25.readFile)(file)) : null;
   if (current !== request.expectedSha256) {
     throw Object.assign(
-      new Error(`${relative.split(import_node_path32.default.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
+      new Error(`${relative.split(import_node_path33.default.sep).join("/")} changed on disk since this page loaded it; press Refresh and edit again`),
       { status: 409 }
     );
   }
-  await (0, import_promises24.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
-  return relative.split(import_node_path32.default.sep).join("/");
+  await (0, import_promises25.writeFile)(file, JSON.stringify(request.set, null, 2) + "\n");
+  return relative.split(import_node_path33.default.sep).join("/");
 }
 
 // src/gallery/edit.ts
@@ -16786,7 +17368,7 @@ function createGalleryEditHandler(opts) {
   const history = /* @__PURE__ */ new Map();
   const manifestOf = async (project) => {
     try {
-      return import_node_path33.default.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
+      return import_node_path34.default.resolve(await opts.manifestFor(typeof project === "string" ? project : void 0));
     } catch {
       return null;
     }
@@ -16796,7 +17378,7 @@ function createGalleryEditHandler(opts) {
     if (undo.success) {
       const manifestPath2 = await manifestOf(undo.data.project);
       if (!manifestPath2) throw new ManifestEditError("no manifest to undo an edit in");
-      const current = await (0, import_promises25.readFile)(manifestPath2, "utf8");
+      const current = await (0, import_promises26.readFile)(manifestPath2, "utf8");
       if (sha256(current) !== undo.data.expectedSha256) throw new ManifestDriftError(manifestPath2);
       const stack = history.get(manifestPath2) ?? [];
       const last = stack[stack.length - 1];
@@ -16806,17 +17388,17 @@ function createGalleryEditHandler(opts) {
         throw Object.assign(new Error("the manifest changed outside the gallery since its last edit; undo would discard that change"), { status: 409 });
       }
       const tmp = manifestPath2 + ".pixelkiln-undo";
-      await (0, import_promises25.writeFile)(tmp, last.before);
-      await (0, import_promises25.rename)(tmp, manifestPath2);
+      await (0, import_promises26.writeFile)(tmp, last.before);
+      await (0, import_promises26.rename)(tmp, manifestPath2);
       stack.pop();
-      log(`  manifest edit undone in ${import_node_path33.default.relative(process.cwd(), manifestPath2) || manifestPath2}`);
+      log(`  manifest edit undone in ${import_node_path34.default.relative(process.cwd(), manifestPath2) || manifestPath2}`);
       return opts.reload();
     }
     const manifestPath = await manifestOf(body?.project);
-    const before = manifestPath ? await (0, import_promises25.readFile)(manifestPath, "utf8").catch(() => null) : null;
+    const before = manifestPath ? await (0, import_promises26.readFile)(manifestPath, "utf8").catch(() => null) : null;
     const build = await apply(body);
     if (manifestPath && before !== null) {
-      const after = await (0, import_promises25.readFile)(manifestPath, "utf8").catch(() => null);
+      const after = await (0, import_promises26.readFile)(manifestPath, "utf8").catch(() => null);
       if (after !== null && after !== before) {
         const stack = history.get(manifestPath) ?? [];
         stack.push({ before, afterSha: sha256(after) });
@@ -16871,7 +17453,7 @@ function createEditApplier(opts, log) {
       } catch (error) {
         throw new ManifestEditError(error instanceof Error ? error.message : String(error));
       }
-      const written = await saveProjectImage(import_node_path33.default.dirname(import_node_path33.default.resolve(manifestPath2)), upload.data);
+      const written = await saveProjectImage(import_node_path34.default.dirname(import_node_path34.default.resolve(manifestPath2)), upload.data);
       log(`  image added: ${written}`);
       return opts.reload();
     }
@@ -16938,7 +17520,7 @@ function createEditApplier(opts, log) {
     }
     const result = await applyManifestEdit(manifestPath, parsed.data);
     if (result.changed) {
-      const relative = import_node_path33.default.relative(process.cwd(), result.manifestPath);
+      const relative = import_node_path34.default.relative(process.cwd(), result.manifestPath);
       const shown = !relative || relative.startsWith("..") ? result.manifestPath : relative;
       log(`  manifest edited: ${describeEdit(parsed.data)} in ${shown}`);
     }
@@ -16966,15 +17548,20 @@ function describeEdit(edit) {
 // src/gallery/snapshot.ts
 var PROJECT_FILE_TYPE = "application/octet-stream";
 function galleryMediaId(absolutePath) {
-  return (0, import_node_crypto7.createHash)("sha256").update(import_node_path34.default.resolve(absolutePath)).digest("hex").slice(0, 24);
+  return (0, import_node_crypto7.createHash)("sha256").update(import_node_path35.default.resolve(absolutePath)).digest("hex").slice(0, 24);
 }
 function galleryMediaRoute(id) {
   return `/media/${id}`;
 }
+function renderedSize(entry) {
+  const vfx = entry?.providerMetadata?.[entry.provider]?.vfx;
+  return typeof vfx?.width === "number" && typeof vfx.height === "number" ? { width: vfx.width, height: vfx.height } : null;
+}
 function isDeclared(loaded, styleId, assetId) {
   const asset = loaded.manifest.assets[assetId];
-  if (!asset || !loaded.manifest.styles[styleId]) return false;
-  return asset.styles.length === 0 || asset.styles.includes(styleId);
+  const style = loaded.manifest.styles[styleId];
+  if (!asset || !style) return false;
+  return assetInStyle(asset, styleId, style);
 }
 function matchesFilter(filter, styleId, assetId) {
   if (filter?.styles?.length && !filter.styles.includes(styleId)) return false;
@@ -16985,9 +17572,9 @@ function describeHistory(media, entry, cacheDir) {
   return (entry.history ?? []).map((generation, i) => {
     const outputs = generation.outputs.map((output) => {
       const mediaType = output.mediaType ?? MediaType.PNG;
-      const file = import_node_path34.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
+      const file = import_node_path35.default.join(cacheDir, cacheFileName(output.sha256, mediaType));
       let url = null;
-      if ((0, import_node_fs29.existsSync)(file)) {
+      if ((0, import_node_fs30.existsSync)(file)) {
         const id = galleryMediaId(file);
         media.set(id, { path: file, contentType: mediaType });
         url = `${galleryMediaRoute(id)}?v=${output.sha256.slice(0, 24)}`;
@@ -17019,7 +17606,7 @@ function describeHistory(media, entry, cacheDir) {
 var MAX_COMPARED_BYTES = 8 * 1024 * 1024;
 async function samePixels(a, b) {
   try {
-    const [left, right] = await Promise.all([(0, import_promises26.readFile)(a), (0, import_promises26.readFile)(b)]);
+    const [left, right] = await Promise.all([(0, import_promises27.readFile)(a), (0, import_promises27.readFile)(b)]);
     if (left.length > MAX_COMPARED_BYTES || right.length > MAX_COMPARED_BYTES) return false;
     const x = decodePng(left);
     const y = decodePng(right);
@@ -17085,7 +17672,7 @@ function describeCharacter(spec, entry) {
 }
 async function fileInfo(absolutePath) {
   try {
-    const info = await (0, import_promises26.stat)(absolutePath);
+    const info = await (0, import_promises27.stat)(absolutePath);
     return info.isFile() ? { bytes: info.size, modifiedAt: info.mtime.toISOString() } : null;
   } catch {
     return null;
@@ -17117,10 +17704,10 @@ async function describeOutput(media, root, absolutePath, recorded = {}) {
 async function describeQuality(media, root, inspection) {
   const outputPaths = inspection.outputs ?? [inspection.output];
   const outputs = await Promise.all(
-    outputPaths.map((file) => describeOutput(media, root, import_node_path34.default.resolve(root, file)))
+    outputPaths.map((file) => describeOutput(media, root, import_node_path35.default.resolve(root, file)))
   );
-  const recordPath = import_node_path34.default.resolve(root, inspection.record);
-  const recordExists = (0, import_node_fs29.existsSync)(recordPath);
+  const recordPath = import_node_path35.default.resolve(root, inspection.record);
+  const recordExists = (0, import_node_fs30.existsSync)(recordPath);
   let options = null;
   let check = null;
   if (recordExists) {
@@ -17139,7 +17726,7 @@ async function describeQuality(media, root, inspection) {
   return {
     state: inspection.state,
     reason: inspection.reason,
-    output: portableOutputPath(import_node_path34.default.resolve(root, inspection.output), root),
+    output: portableOutputPath(import_node_path35.default.resolve(root, inspection.output), root),
     record: portableOutputPath(recordPath, root),
     recordExists,
     outputs,
@@ -17177,9 +17764,9 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await (0, import_promises26.readFile)(loaded.path, "utf8");
+  const manifestText = await (0, import_promises27.readFile)(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
-  const cacheDir = import_node_path34.default.resolve(import_node_path34.default.dirname(opts.lockPath), ".pixelkiln", "cache");
+  const cacheDir = import_node_path35.default.resolve(import_node_path35.default.dirname(opts.lockPath), ".pixelkiln", "cache");
   let rawStyles = {};
   try {
     const raw = JSON.parse(manifestText);
@@ -17203,12 +17790,12 @@ async function buildGallerySnapshot(opts) {
         )
       );
       if (spec.source) {
-        const editPath = import_node_path34.default.resolve(root, spec.source);
+        const editPath = import_node_path35.default.resolve(root, spec.source);
         const memberCount = sourceIsStem(spec.source, entry, root) ? entry.outputs.length : 1;
         const editShas = await Promise.all(
           Array.from({ length: memberCount }, async (_, index) => {
             const file = sourceOutputPath(spec.source, entry, index, root);
-            return { file, sha256: (0, import_node_fs29.existsSync)(file) ? await sha256File(file) : null };
+            return { file, sha256: (0, import_node_fs30.existsSync)(file) ? await sha256File(file) : null };
           })
         );
         edits = await Promise.all(editShas.map(({ file, sha256: editSha }) => describeOutput(media, root, file, { sha256: editSha })));
@@ -17216,7 +17803,7 @@ async function buildGallerySnapshot(opts) {
         const companion = await readHandEditCompanion(editPath);
         if (companion) {
           const projectPath = handEditProjectPath(editPath);
-          const project = companion.project && (0, import_node_fs29.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
+          const project = companion.project && (0, import_node_fs30.existsSync)(projectPath) ? await fileInfo(projectPath) : null;
           let projectUrl = null;
           if (project) {
             const id = galleryMediaId(projectPath);
@@ -17252,8 +17839,8 @@ async function buildGallerySnapshot(opts) {
         editStatus = edits.some((member) => !member.exists) ? "missing" : editChanged.every((changed) => !changed) ? "same" : regenerated ? "regenerated-since" : "edited";
       }
     } else if (spec.source) {
-      outputs = [await describeOutput(media, root, import_node_path34.default.resolve(root, spec.source))];
-    } else if (!entry && (0, import_node_fs29.existsSync)(spec.outFile)) {
+      outputs = [await describeOutput(media, root, import_node_path35.default.resolve(root, spec.source))];
+    } else if (!entry && (0, import_node_fs30.existsSync)(spec.outFile)) {
       outputs = [await describeOutput(media, root, spec.outFile)];
     } else {
       outputs = [];
@@ -17274,8 +17861,8 @@ async function buildGallerySnapshot(opts) {
       generator: entry?.generator ?? spec.generator,
       prompt: entry?.prompt ?? spec.prompt,
       currentPrompt: entry && entry.prompt !== spec.prompt ? spec.prompt : null,
-      width: entry?.width ?? spec.width,
-      height: entry?.height ?? spec.height,
+      width: renderedSize(entry)?.width ?? entry?.width ?? spec.width,
+      height: renderedSize(entry)?.height ?? entry?.height ?? spec.height,
       tileFeature: entry?.tileFeature ?? spec.tileFeature ?? null,
       fps: quality?.frameSet?.fps ?? metadataFps(entry) ?? spec.quality?.fps ?? null,
       cost: entry?.cost ?? 0,
@@ -17456,7 +18043,7 @@ async function buildGallerySnapshot(opts) {
       id: loaded.manifest.name,
       name: loaded.manifest.name,
       manifest: loaded.path,
-      lock: import_node_path34.default.resolve(opts.lockPath),
+      lock: import_node_path35.default.resolve(opts.lockPath),
       root,
       provider: loaded.manifest.provider,
       account: null,
@@ -17482,7 +18069,7 @@ async function buildGallerySnapshot(opts) {
   return { snapshot, media };
 }
 async function buildWorkspaceGallerySnapshot(opts) {
-  const dir = import_node_path34.default.dirname(import_node_path34.default.resolve(opts.workspacePath));
+  const dir = import_node_path35.default.dirname(import_node_path35.default.resolve(opts.workspacePath));
   const media = /* @__PURE__ */ new Map();
   const projects = [];
   const items = [];
@@ -17525,11 +18112,11 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: loaded.manifest.name,
         manifest: manifestPath,
-        lock: import_node_path34.default.resolve(lockPath),
+        lock: import_node_path35.default.resolve(lockPath),
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises26.readFile)(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await (0, import_promises27.readFile)(manifestPath, "utf8")),
         historyLimit: historyLimit(loaded.manifest),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
@@ -17541,8 +18128,8 @@ async function buildWorkspaceGallerySnapshot(opts) {
         id: project.id,
         name: project.id,
         manifest: manifestPath,
-        lock: import_node_path34.default.resolve(lockPath),
-        root: import_node_path34.default.dirname(manifestPath),
+        lock: import_node_path35.default.resolve(lockPath),
+        root: import_node_path35.default.dirname(manifestPath),
         provider: project.provider,
         account: project.account ?? null,
         manifestSha256: null,
@@ -17569,7 +18156,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
       version: 1,
       generatedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       project: null,
-      workspace: { path: import_node_path34.default.resolve(opts.workspacePath), dir, projects },
+      workspace: { path: import_node_path35.default.resolve(opts.workspacePath), dir, projects },
       filter,
       totals: {
         entries: projects.reduce((sum, project) => sum + project.entries, 0),
@@ -17586,7 +18173,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 
 // src/gallery/page.ts
-var import_node_fs30 = require("fs");
+var import_node_fs31 = require("fs");
 
 // src/gallery/client-bundle.ts
 var import_node_module = require("module");
@@ -17626,8 +18213,8 @@ var client;
 function clientAssets() {
   const prebuilt = new URL("gallery.js", CLIENT_DIR);
   client ??= {
-    css: (0, import_node_fs30.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
-    js: (0, import_node_fs30.existsSync)(prebuilt) ? (0, import_node_fs30.readFileSync)(prebuilt, "utf8") : bundleGalleryClient()
+    css: (0, import_node_fs31.readFileSync)(new URL("gallery.css", CLIENT_DIR), "utf8"),
+    js: (0, import_node_fs31.existsSync)(prebuilt) ? (0, import_node_fs31.readFileSync)(prebuilt, "utf8") : bundleGalleryClient()
   };
   return client;
 }
@@ -17770,10 +18357,10 @@ var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download
 
 // src/editor/install.ts
 var import_node_crypto8 = require("crypto");
-var import_node_fs31 = require("fs");
-var import_promises27 = require("fs/promises");
+var import_node_fs32 = require("fs");
+var import_promises28 = require("fs/promises");
 var import_node_os4 = __toESM(require("os"), 1);
-var import_node_path35 = __toESM(require("path"), 1);
+var import_node_path36 = __toESM(require("path"), 1);
 var EditorInstallError = class extends Error {
   constructor(message6, file) {
     super(message6);
@@ -17784,15 +18371,15 @@ var EditorInstallError = class extends Error {
 };
 function editorToolsRoot() {
   const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
-  if (override) return import_node_path35.default.resolve(override);
-  if (process.platform === "darwin") return import_node_path35.default.join(import_node_os4.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (override) return import_node_path36.default.resolve(override);
+  if (process.platform === "darwin") return import_node_path36.default.join(import_node_os4.default.homedir(), "Library", "Caches", "pixelkiln", "tools");
   if (process.platform === "win32") {
-    return import_node_path35.default.join(process.env.LOCALAPPDATA ?? import_node_path35.default.join(import_node_os4.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+    return import_node_path36.default.join(process.env.LOCALAPPDATA ?? import_node_path36.default.join(import_node_os4.default.homedir(), "AppData", "Local"), "pixelkiln", "tools");
   }
-  return import_node_path35.default.join(process.env.XDG_CACHE_HOME ?? import_node_path35.default.join(import_node_os4.default.homedir(), ".cache"), "pixelkiln", "tools");
+  return import_node_path36.default.join(process.env.XDG_CACHE_HOME ?? import_node_path36.default.join(import_node_os4.default.homedir(), ".cache"), "pixelkiln", "tools");
 }
 function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
-  return import_node_path35.default.join(root, "pixelorama", pin.release ?? "unpublished");
+  return import_node_path36.default.join(root, "pixelorama", pin.release ?? "unpublished");
 }
 function editorBaseUrl(pin = EDITOR_PIN) {
   const override = process.env.PIXELKILN_EDITOR_URL?.trim();
@@ -17802,7 +18389,7 @@ function editorBaseUrl(pin = EDITOR_PIN) {
 }
 async function sha256Of(file) {
   try {
-    return (0, import_node_crypto8.createHash)("sha256").update(await (0, import_promises27.readFile)(file)).digest("hex");
+    return (0, import_node_crypto8.createHash)("sha256").update(await (0, import_promises28.readFile)(file)).digest("hex");
   } catch {
     return null;
   }
@@ -17815,8 +18402,8 @@ async function editorStatus(opts = {}) {
   let totalBytes = 0;
   for (const [name, expected] of Object.entries(pin.files)) {
     totalBytes += expected.bytes;
-    const file = import_node_path35.default.join(dir, name);
-    const info = (0, import_node_fs31.existsSync)(file) ? await (0, import_promises27.stat)(file).catch(() => null) : null;
+    const file = import_node_path36.default.join(dir, name);
+    const info = (0, import_node_fs32.existsSync)(file) ? await (0, import_promises28.stat)(file).catch(() => null) : null;
     if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
       installedBytes += expected.bytes;
     } else {
@@ -17845,7 +18432,7 @@ async function installEditor(opts = {}) {
     );
   }
   if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
-  await (0, import_promises27.mkdir)(dir, { recursive: true });
+  await (0, import_promises28.mkdir)(dir, { recursive: true });
   const downloaded = [];
   const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
   let fetchedBytes = before.installedBytes;
@@ -17873,13 +18460,13 @@ async function installEditor(opts = {}) {
     if (digest2 !== expected.sha256) {
       throw new EditorInstallError(`${name}: sha256 ${digest2.slice(0, 12)}\u2026 does not match the pinned ${expected.sha256.slice(0, 12)}\u2026`, name);
     }
-    const final = import_node_path35.default.join(dir, name);
+    const final = import_node_path36.default.join(dir, name);
     const tmp = `${final}.${process.pid}.part`;
     try {
-      await (0, import_promises27.writeFile)(tmp, bytes);
-      await (0, import_promises27.rename)(tmp, final);
+      await (0, import_promises28.writeFile)(tmp, bytes);
+      await (0, import_promises28.rename)(tmp, final);
     } finally {
-      await (0, import_promises27.rm)(tmp, { force: true });
+      await (0, import_promises28.rm)(tmp, { force: true });
     }
     fetchedBytes += bytes.length;
     downloaded.push(name);
@@ -17919,12 +18506,12 @@ var EDITOR_CONTENT_TYPES = {
   ".json": "application/json; charset=utf-8"
 };
 function editorContentType(name) {
-  return EDITOR_CONTENT_TYPES[import_node_path35.default.extname(name).toLowerCase()] ?? null;
+  return EDITOR_CONTENT_TYPES[import_node_path36.default.extname(name).toLowerCase()] ?? null;
 }
 
 // src/gallery/editor.ts
-var import_promises28 = require("fs/promises");
-var import_node_path36 = __toESM(require("path"), 1);
+var import_promises29 = require("fs/promises");
+var import_node_path37 = __toESM(require("path"), 1);
 function editorRoute(release, name = "index.html") {
   return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
 }
@@ -17997,7 +18584,7 @@ function createGalleryEditorHandlers(opts = {}) {
       if (!status.installed) return null;
       let bytes;
       try {
-        bytes = await (0, import_promises28.readFile)(import_node_path36.default.join(dir, name));
+        bytes = await (0, import_promises29.readFile)(import_node_path37.default.join(dir, name));
       } catch {
         verified = null;
         return null;
@@ -18014,7 +18601,7 @@ function createGalleryEditorHandlers(opts = {}) {
 // src/gallery/server.ts
 var import_node_crypto9 = require("crypto");
 var import_node_http2 = require("http");
-var import_promises29 = require("fs/promises");
+var import_promises30 = require("fs/promises");
 var MAX_EDIT_BYTES = 48 * 1024 * 1024;
 var EDITOR_CSP = [
   "default-src 'self'",
@@ -18195,7 +18782,7 @@ async function serveGallery(opts) {
         const asset = reviewAssets.get(jobId)?.get(url2.pathname);
         if (!asset) return fail(404, "no such review asset");
         try {
-          const bytes = await (0, import_promises29.readFile)(asset.path);
+          const bytes = await (0, import_promises30.readFile)(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -18278,7 +18865,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await (0, import_promises29.readFile)(asset.path);
+          bytes = await (0, import_promises30.readFile)(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -18688,19 +19275,19 @@ function createGenerateHandlers(opts) {
 }
 
 // src/pipeline/salvage.ts
-var import_promises30 = require("fs/promises");
-var import_node_fs32 = require("fs");
-var import_node_path37 = __toESM(require("path"), 1);
+var import_promises31 = require("fs/promises");
+var import_node_fs33 = require("fs");
+var import_node_path38 = __toESM(require("path"), 1);
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
 async function loadClaims(lockPaths, opts = {}) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
-    if (!(0, import_node_fs32.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!(0, import_node_fs33.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await (0, import_promises30.readFile)(p, "utf8")));
+      parsed = parseLock(JSON.parse(await (0, import_promises31.readFile)(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -18804,20 +19391,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = import_node_path37.default.resolve(ownManifestPath);
+  const own = import_node_path38.default.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => import_node_path37.default.join(import_node_path37.default.dirname(import_node_path37.default.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => import_node_path38.default.join(import_node_path38.default.dirname(import_node_path38.default.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (import_node_path37.default.resolve(siblingManifestPath) === own) continue;
-    if (!(0, import_node_fs32.existsSync)(siblingManifestPath)) continue;
+    if (import_node_path38.default.resolve(siblingManifestPath) === own) continue;
+    if (!(0, import_node_fs33.existsSync)(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: import_node_path37.default.basename(import_node_path37.default.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: import_node_path38.default.basename(import_node_path38.default.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -18937,8 +19524,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-var import_promises31 = require("fs/promises");
-var import_node_path38 = __toESM(require("path"), 1);
+var import_promises32 = require("fs/promises");
+var import_node_path39 = __toESM(require("path"), 1);
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -19104,7 +19691,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: import_node_path38.default.relative(process.cwd(), ctx.importDir) || "."
+    importDir: import_node_path39.default.relative(process.cwd(), ctx.importDir) || "."
   });
   const byId = new Map(orphans.map((o) => [o.id, o]));
   const existingTags = new Map(orphans.map((o) => [o.id, o.tags]));
@@ -19160,10 +19747,10 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE2)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = import_node_path38.default.join("_salvaged", `${assetId}.png`);
-            const outFile = import_node_path38.default.resolve(ctx.importDir, rel);
-            await (0, import_promises31.mkdir)(import_node_path38.default.dirname(outFile), { recursive: true });
-            await (0, import_promises31.writeFile)(outFile, buf);
+            const rel = import_node_path39.default.join("_salvaged", `${assetId}.png`);
+            const outFile = import_node_path39.default.resolve(ctx.importDir, rel);
+            await (0, import_promises32.mkdir)(import_node_path39.default.dirname(outFile), { recursive: true });
+            await (0, import_promises32.writeFile)(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -19195,7 +19782,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, import_node_path38.default.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, import_node_path39.default.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -19219,9 +19806,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log, characters: characterMembers });
-      const raw = JSON.parse(await (0, import_promises31.readFile)(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await (0, import_promises32.readFile)(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await (0, import_promises31.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await (0, import_promises32.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       if (characterAssetIds.length) result.characterAssetIds = characterAssetIds;
       return result;
@@ -19332,6 +19919,7 @@ async function workspaceStatus(ws, dir) {
 0 && (module.exports = {
   AssetBatchSchema,
   AssetSchema,
+  AssetVfxSchema,
   BudgetError,
   CHARACTER_DIRECTIONS_4,
   CHARACTER_DIRECTIONS_8,
@@ -19388,12 +19976,14 @@ async function workspaceStatus(ws, dir) {
   OverwriteRefusedError,
   PIXELATE_COST_GENERATIONS,
   PIXELATE_MAX_SIDE,
+  PIXELLAB_MCP_URL,
   PIXEL_ART_FIXER_REVISION,
   PIXEL_ART_FIXER_URL,
   PRO_TIER_PRICES,
   PixelKilnError,
   PixelLabClient,
   PixelLabError,
+  PixelLabMcpClient,
   PixelLabProvider,
   PostprocessSchema,
   ProjectError,
@@ -19416,12 +20006,15 @@ async function workspaceStatus(ws, dir) {
   UiPieceSchema,
   UnsupportedCapabilityError,
   UsageError,
+  VFX_TOOL,
+  VfxPartSchema,
   WorkspaceProjectSchema,
   WorkspaceSchema,
   adopt,
   applyManifestEdit,
   applyTags,
   approveQualityRecord,
+  assetInStyle,
   auditStyle,
   availableProviders,
   backoffMs,
@@ -19448,6 +20041,7 @@ async function workspaceStatus(ws, dir) {
   defaultOpenCommand,
   defaultPixelateOut,
   defaultUnzoomOut,
+  describeVfx,
   detachHandEdit,
   detectMediaType,
   doctor,
@@ -19468,6 +20062,7 @@ async function workspaceStatus(ws, dir) {
   fontOutputPaths,
   formatCost,
   frameSetFps,
+  frameSetLoop,
   galleryContentSecurityPolicy,
   galleryMediaId,
   galleryMediaRoute,
@@ -19490,9 +20085,11 @@ async function workspaceStatus(ws, dir) {
   inspectRevisionReadiness,
   installEditor,
   installRecipe,
+  isBusyReply,
   isFrameSetEntry,
   isMemberSetEntry,
   isSensitiveSourceUrl,
+  isVfxReference,
   isometricTileCost,
   listBundledRecipes,
   loadClaims,
@@ -19501,7 +20098,9 @@ async function workspaceStatus(ws, dir) {
   loadSiblingManifests,
   loadWorkspace,
   lockKey,
+  makeVfx,
   matchOrphanStyle,
+  mcpClientFromEnv,
   measureBalanceChange,
   measureDecodedImageQuality,
   measureImageQuality,
@@ -19525,8 +20124,12 @@ async function workspaceStatus(ws, dir) {
   paletteDistance,
   parentAssetId,
   parseLock,
+  parseMcpBody,
   parseProFlashQuote,
   parseTerrainDescriptions,
+  parseVfxExport,
+  parseVfxRecipe,
+  parseVfxStep,
   parseWorkspace,
   pickHistory,
   pixelateFile,
@@ -19546,6 +20149,8 @@ async function workspaceStatus(ws, dir) {
   readArtifactBundleManifest,
   readHandEditCompanion,
   readQualityBaseline,
+  readSavedVfxRecipe,
+  readVfxRecipe,
   recipeDigest,
   referencedHashes,
   refineAsset,
@@ -19576,6 +20181,7 @@ async function workspaceStatus(ws, dir) {
   resolveSpecs,
   resolveStyleImages,
   resolveStyleOutputs,
+  resolveVfxSprite,
   resumeActions,
   resumeCommandForStatus,
   retireGeneration,
@@ -19583,6 +20189,7 @@ async function workspaceStatus(ws, dir) {
   revertGeneration,
   runPicker,
   runSalvage,
+  runVfxWorkbench,
   saveHandEdit,
   saveLock,
   saveWorkspace,
@@ -19593,6 +20200,7 @@ async function workspaceStatus(ws, dir) {
   sha256File,
   shouldPersistSourceUrl,
   shouldRetry,
+  sliceVfxSheet,
   slugify,
   snapshotQualityBaseline,
   sourceIsStem,
@@ -19617,6 +20225,8 @@ async function workspaceStatus(ws, dir) {
   validateWorkspace,
   verifyArtifactBundle,
   verifyRecipe,
+  vfxOutputPaths,
+  vfxRecipeSha256,
   withArtifactManifest,
   workspaceClaims,
   workspaceStatus,