pixelkiln 0.88.0 → 0.89.0

package/dist/index.js

@@ -14,8 +14,10 @@ var RevisionModeSchema = z.enum([
   "animate-pixminimax",
   "animate-skeleton",
   "interpolate",
-  "edit-animation"
+  "edit-animation",
+  "normal-map"
 ]);
+var NormalMapConventionSchema = z.enum(["opengl", "directx"]);
 function tileVariationCount(descriptions) {
   return Math.max(1, descriptions) * 4;
 }
@@ -58,9 +60,16 @@ function tilesCost(tileSize, variations) {
 function isometricTileCost() {
   return 1;
 }
-function terrainTileCount(transitionSize) {
+function terrainTileCount(transitionSize, mode2, orientation) {
+  if (orientation === "sidescroller") return 16;
+  if (mode2 === "pro") return transitionSize != null && transitionSize > 0.4 ? 25 : 16;
   return transitionSize === 1 ? 25 : 16;
 }
+function terrainCost(mode2, tileSize, orientation) {
+  if (orientation === "sidescroller") return 3;
+  if (mode2 === "pro") return tileSize <= 32 ? 15 : 25;
+  return 4;
+}
 function parseTerrainDescriptions(prompt) {
   const parts = prompt.split(/\d+\s*\)\s*\./).map((part) => part.trim()).filter(Boolean);
   if (parts.length < 2) return null;
@@ -196,6 +205,17 @@ var CharacterStateSchema = z.object({
     height: z.number().int().min(16).max(256)
   }).strict().optional()
 }).strict();
+var TerrainSideSchema = z.enum(["lower", "upper"]);
+var TerrainLinkSchema = z.object({
+  /** A terrain asset in the same style. */
+  of: z.string().min(1),
+  /** Which of that set's terrains: its `lower` or its `upper`. */
+  terrain: TerrainSideSchema
+}).strict();
+var TerrainConnectSchema = z.object({
+  lower: TerrainLinkSchema.optional(),
+  upper: TerrainLinkSchema.optional()
+}).strict().refine((connect) => connect.lower || connect.upper, { message: "connect needs lower, upper, or both" });
 var CharacterPortraitSizeSchema = z.union([
   z.literal(16),
   z.literal(32),
@@ -226,13 +246,38 @@ var AssetVfxSchema = z.object({
   parts: z.array(VfxPartSchema).optional(),
   sprite: z.string().min(1).optional(),
   fps: z.number().int().min(1).max(60).optional(),
-  name: z.string().min(1).optional()
+  name: z.string().min(1).optional(),
+  description: z.string().trim().min(1).max(8e3).optional(),
+  artist: z.enum(["lite", "pro"]).optional()
 }).strict().superRefine((vfx, context) => {
+  if (vfx.description !== void 0) {
+    for (const key of ["preset", "recipe", "parts", "fps"]) {
+      if (vfx[key] !== void 0) {
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `a vfx description goes to PixelLab's VFX artist, which takes no ${key}; use a description or the workbench's preset/recipe/parts/fps, not both`,
+          path: [key]
+        });
+      }
+    }
+    if (vfx.sprite && /^(character|object|gallery):/.test(vfx.sprite)) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "the VFX artist takes a sprite's pixels, not a PixelLab reference; point sprite at a PNG file (another asset's output works)",
+        path: ["sprite"]
+      });
+    }
+    if (vfx.name && vfx.name.length > 80) {
+      context.addIssue({ code: z.ZodIssueCode.custom, message: "the VFX artist takes a name of at most 80 characters", path: ["name"] });
+    }
+  } else if (vfx.artist) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: "artist picks who draws a vfx description; add a description", path: ["artist"] });
+  }
   if (vfx.preset && vfx.recipe) {
     context.addIssue({ code: 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: z.ZodIssueCode.custom, message: "a vfx needs a preset, a recipe, or at least one part", path: ["preset"] });
+  if (vfx.description === void 0 && !vfx.preset && !vfx.recipe && !vfx.parts?.length) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: "a vfx needs a preset, a recipe, or at least one part, or a description", path: ["preset"] });
   }
   if (vfx.sprite && /^(https?|data):/i.test(vfx.sprite)) {
     context.addIssue({
@@ -417,6 +462,8 @@ var RevisionSchema = z.object({
   skeletonTemplate: z.string().min(1).optional(),
   /** `remove-background` only: `simple` is faster and suits flat backgrounds; `complex` handles detailed edges. PixelLab defaults to `simple`. */
   removalTask: z.enum(["simple", "complex"]).optional(),
+  /** `normal-map` only: `opengl` (green up; PixelLab's default) or `directx` (green down, for Unreal). */
+  convention: NormalMapConventionSchema.optional(),
   /**
    * `animate-skeleton`: what the character *looks like*, a noun
    * phrase (colours, clothing, held items) — distinct from the asset's
@@ -563,13 +610,20 @@ var RevisionSchema = z.object({
       path: ["removalTask"]
     });
   }
-  if (revision.strength !== void 0 && revision.mode === "remove-background") {
+  if (revision.strength !== void 0 && (revision.mode === "remove-background" || revision.mode === "normal-map")) {
     context.addIssue({
       code: z.ZodIssueCode.custom,
-      message: "remove-background revisions do not take a strength",
+      message: `${revision.mode} revisions do not take a strength`,
       path: ["strength"]
     });
   }
+  if (revision.convention !== void 0 && revision.mode !== "normal-map") {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "convention applies to normal-map revisions only",
+      path: ["convention"]
+    });
+  }
   if (revision.description !== void 0 && revision.mode !== "animate-skeleton" && revision.mode !== "remove-background") {
     context.addIssue({
       code: z.ZodIssueCode.custom,
@@ -588,7 +642,7 @@ var RevisionSchema = z.object({
   }
 });
 var FRAME_SET_REVISION_MODES = ["animate", "animate-pixminimax", "animate-skeleton", "interpolate", "edit-animation"];
-var MEMBER_SET_REVISION_MODES = ["reduce-colors", "correct-pixelart", "edit-animation"];
+var MEMBER_SET_REVISION_MODES = ["reduce-colors", "correct-pixelart", "edit-animation", "normal-map"];
 var StyleObjectSchema = z.object({
   /** Generation backend for this style. Omit to inherit the manifest default. */
   provider: z.string().min(1).optional(),
@@ -701,9 +755,10 @@ var StyleObjectSchema = z.object({
   terrainTileSize: z.union([z.literal(16), z.literal(32), z.literal(64)]).optional(),
   /**
    * `terrain` generator only. `standard` is the classic Wang tileset
-   * pipeline; `pro` is a newer corner-pair pipeline with its own shape
-   * controls (`terrainSpreadX`, `terrainSlopeSize`, `terrainRaggedness`)
-   * in place of `terrainShapeStyle`. The API default is `standard`.
+   * pipeline; `pro` is a newer pipeline with its own shape controls
+   * (`terrainRaggedness`, `terrainRoundness`, `terrainBoundaryAmplitude`,
+   * `terrainStepSlope`, `terrainConnectDiagonals`) in place of
+   * `terrainShapeStyle`. The API default is `standard`.
    */
   terrainMode: z.enum(["standard", "pro"]).optional(),
   /**
@@ -715,31 +770,86 @@ var StyleObjectSchema = z.object({
   /**
    * `terrain` generator only, `terrainMode: "standard"`. Procedural
    * boundary geometry: `square` or `round`, 16px or 32px tiles only.
-   * Rejected together with `terrainMode: "pro"`, whose own shape controls
-   * are `terrainSpreadX`/`terrainSlopeSize`/`terrainRaggedness`.
+   * Rejected together with `terrainMode: "pro"`, which has its own shape
+   * controls.
    */
   terrainShapeStyle: z.enum(["square", "round"]).optional(),
-  /** `terrain` generator only, `terrainMode: "pro"`. Boundary spread
-   *  between terrains (0 = steep, 1 = gradual). API default 0.5. */
+  /**
+   * Deprecated: no effect. PixelLab's Pro pipeline no longer reads
+   * `spread_x`; the API keeps accepting it so existing calls work, and so
+   * does pixelkiln. Use `terrainBoundaryAmplitude` or `terrainStepSlope`.
+   */
   terrainSpreadX: z.number().min(0).max(1).optional(),
-  /** `terrain` generator only, `terrainMode: "pro"`. Slope on the N/W/E
-   *  sides as a fraction of wall height. API default 0. */
+  /**
+   * Deprecated: no effect. PixelLab's Pro pipeline no longer reads
+   * `slope_size`; the API keeps accepting it so existing calls work, and
+   * so does pixelkiln. `terrainStepSlope` is the slope control now.
+   */
   terrainSlopeSize: z.number().min(0).max(1).optional(),
   /** `terrain` generator only, `terrainMode: "pro"`. Terrain boundary
-   *  noise (0 = smooth, 1 = rough). API default 0. */
+   *  noise (0 = smooth, 1 = rough), half strength on tall sets
+   *  (`terrainTransitionSize` above 0.4). API default 0. */
   terrainRaggedness: z.number().min(0).max(1).optional(),
+  /**
+   * `terrain` generator only, `terrainMode: "pro"` or `terrainShapeStyle`.
+   * Corner shape of the border between the terrains: 0 square, 1 round,
+   * 2 corners cut at 45° (values between blend). Above 1 needs pro. The API
+   * default is 0.85 on pro and 0.6 with a shape style. With
+   * `terrainConnectDiagonals`, 2 is the fix for 45° paths and coastlines
+   * that otherwise break into one island per step.
+   */
+  terrainRoundness: z.number().min(0).max(2).optional(),
+  /**
+   * `terrain` generator only, `terrainMode: "pro"` (any transition size)
+   * or `terrainShapeStyle` (transition size up to 0.5). How far the border
+   * meanders instead of running straight: 0 straight (the default) to 0.3.
+   * Tiles still connect seamlessly.
+   */
+  terrainBoundaryAmplitude: z.number().min(0).max(0.3).optional(),
+  /**
+   * `terrain` generator only, with `terrainBoundaryAmplitude`. Picks the
+   * meander's shape: another number gives a different border at the same
+   * amplitude, the same number the same border. API default 0.
+   */
+  terrainBoundarySeed: z.number().int().min(0).optional(),
+  /**
+   * `terrain` generator only, `terrainMode: "pro"` with
+   * `terrainTransitionSize: 0.25`. How the bank between the terrains
+   * falls: 0 a straight cliff (the default) to 2 a gentle slope spread
+   * over more ground.
+   */
+  terrainStepSlope: z.number().min(0).max(2).optional(),
+  /**
+   * `terrain` generator only, `terrainMode: "pro"`. On the two diagonal
+   * tiles (upper terrain in opposite corners), true joins the upper
+   * corners through the middle into one area; false (the default) runs the
+   * lower terrain between them.
+   */
+  terrainConnectDiagonals: z.boolean().optional(),
   /**
    * `terrain` generator only. Visual height of the step between lower and
    * upper terrain. Without `terrainShapeStyle`, only 0, 0.25, 0.5, or 1 are
-   * accepted (1 switches to the 25-tile cliff layout, where corners take a
-   * third "transition" value); with it, any value from 0 to 1 works, but
-   * above 0.5 switches to an extended 32-tile layout this adapter does not
-   * model. API default 0.
+   * accepted. Standard switches to the 25-tile cliff layout at 1, where
+   * corners take a third "transition" value; Pro reads it as wall height
+   * and switches to the 25-tile tall-wall layout above 0.4, so 0.5 is
+   * already 25 tiles there. With `terrainShapeStyle`, any value from 0 to 1
+   * works, but above 0.5 switches to an extended 32-tile layout this
+   * adapter does not model. API default 0.
    */
   terrainTransitionSize: z.number().min(0).max(1).optional(),
   /** `terrain` generator only. Camera angle; the API default is `high
    *  top-down`. */
   terrainView: z.enum(["low top-down", "high top-down"]).optional(),
+  /**
+   * `terrain` generator only. `top-down` (the default) is a two-terrain
+   * map set from `/create-tileset`; `sidescroller` is a platform set from
+   * `/create-tileset-sidescroller`, seen from the side: the prompt's 1).
+   * is the platform body and 2). the top layer on it (grass, snow, moss),
+   * and the set's other terrain is empty air. 16 or 32px tiles,
+   * `terrainTransitionSize` 0, 0.25, 0.5, or 1 (the top layer's height),
+   * and none of the top-down mode, view, or shape controls.
+   */
+  terrainOrientation: z.enum(["top-down", "sidescroller"]).optional(),
   /**
    * `isometricTile` generator only. `/create-isometric-tile`'s own tile
    * grid size, distinct from `size` (the generation canvas, 16-64px — the
@@ -819,7 +929,9 @@ var StyleObjectSchema = z.object({
   /** Fixed seed for reproducibility where the endpoint supports it. */
   seed: z.number().int().optional(),
   /**
-   * Forced palette, as `#rrggbb` values. `pixflux` only.
+   * Forced palette, as `#rrggbb` values. Sent as a swatch to `pixflux`
+   * and the generators that take one, and to `imagePro` as its
+   * `target_palette.colors` (2 to 256 colours).
    *
    * Unlike prose, this is a hard constraint. The API is handed a swatch
    * image and the output is limited to those colours. Verified: a four-colour
@@ -829,6 +941,10 @@ var StyleObjectSchema = z.object({
    * chocolate bar.
    */
   palette: z.array(HexColorSchema).default([]),
+  /** `imagePro` only: the palette's name ("Game Boy", "PICO-8"), which PixelLab uses to help the look. Needs `palette`. */
+  paletteName: z.string().min(1).max(100).optional(),
+  /** `imagePro` only: at most this many colours in each candidate, 2 to 64 (drawn from `palette` when one is set). */
+  maxColors: z.number().int().min(2).max(64).optional(),
   /**
    * Snap every visible pixel of the downloaded art to the nearest `palette`
    * colour, without dithering. The palette is sent to providers that take
@@ -882,6 +998,22 @@ var StyleSchema = StyleObjectSchema.refine((s) => !(s.tileFeature && s.styleImag
       path: ["quality"]
     });
   }
+  for (const field of ["paletteName", "maxColors"]) {
+    if (style[field] !== void 0 && style.generator !== "imagePro") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `${field} applies to the imagePro generator only`,
+        path: [field]
+      });
+    }
+  }
+  if (style.paletteName !== void 0 && style.palette.length === 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "paletteName names the palette's colours; set palette too",
+      path: ["paletteName"]
+    });
+  }
   if (style.enforcePalette && style.palette.length < 2) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
@@ -1007,6 +1139,8 @@ var AssetSchema = z.object({
   scene: MapSceneSchema.optional(),
   /** `vfx` styles only: the effect to render. See `AssetVfxSchema`. */
   vfx: AssetVfxSchema.optional(),
+  /** `terrain` styles only: share a terrain with another set. See `TerrainConnectSchema`. */
+  connect: TerrainConnectSchema.optional(),
   /** `character` styles, `standard` humanoid bases: this character's proportions, over the style's. */
   proportions: CharacterProportionsSchema.optional(),
   /**
@@ -1083,7 +1217,7 @@ var AssetSchema = 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", asset.vfx && "vfx"].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", asset.connect && "connect"].filter(Boolean);
   if (shapes.length > 1) {
     context.addIssue({
       code: z.ZodIssueCode.custom,
@@ -1175,6 +1309,10 @@ var LockSourceSchema = z.object({
   role: z.string().optional(),
   mediaType: MediaTypeSchema.optional()
 });
+var LockTerrainConnectSchema = z.record(
+  TerrainSideSchema,
+  z.object({ sourceAssetId: z.string().min(1), sourceObjectId: z.string().min(1) }).strict()
+);
 var LockHistoryEntrySchema = z.object({
   specHash: z.string(),
   generator: GeneratorSchema,
@@ -1197,6 +1335,8 @@ var LockHistoryEntrySchema = z.object({
   billed: z.object({ amount: z.number(), unit: z.string() }).nullable().default(null),
   provider: z.string().default("pixellab"),
   postprocess: PostprocessSchema.optional(),
+  /** A connected terrain set's other sets; see LockEntrySchema.terrainConnect. */
+  terrainConnect: LockTerrainConnectSchema.optional(),
   /** When the replacement was submitted. */
   retiredAt: z.string()
 });
@@ -1235,6 +1375,7 @@ var LockEntrySchema = z.object({
     skeletonTemplate: z.string().min(1).optional(),
     description: z.string().min(1).optional(),
     removalTask: z.enum(["simple", "complex"]).optional(),
+    convention: NormalMapConventionSchema.optional(),
     driftThreshold: z.number().min(0).optional(),
     subjectDescription: z.string().min(1).max(300).optional(),
     initialPose: z.string().min(1).max(300).optional(),
@@ -1262,6 +1403,14 @@ var LockEntrySchema = z.object({
     sourceSha256: z.string().regex(/^[0-9a-f]{64}$/),
     referenceSha256: z.string().regex(/^[0-9a-f]{64}$/)
   }).strict().nullable().default(null),
+  /**
+   * For a connected terrain set: per side of this set, the set it shares
+   * that terrain with and that set's provider id when this was submitted.
+   * Tracked the way `outfit` is, not through `specHash`: the other set's
+   * id lives in the lockfile, which manifest resolution does not read.
+   * Absent (not null) otherwise, so other entries do not grow the key.
+   */
+  terrainConnect: LockTerrainConnectSchema.optional(),
   /**
    * Output hashes owned by the previous generation while its replacement is
    * pending. They authorize replacing only unchanged PixelKiln-owned files.
@@ -1586,7 +1735,16 @@ var TilesetGetSchema = z3.object({
     terrain_types: z3.array(z3.string()),
     tiles: z3.array(TilesetTileSchema).min(1)
   }).passthrough(),
-  usage: UsageSchema
+  usage: UsageSchema,
+  /**
+   * `terrain_ids` names each terrain's base tile id: the id another set
+   * sends as `lower_base_tile_id`/`upper_base_tile_id` to share that
+   * terrain. A sidescroller set has only `lower` (its upper is empty air).
+   */
+  metadata: z3.object({
+    terrain_ids: z3.record(z3.string()).nullable().optional(),
+    view: z3.string().nullable().optional()
+  }).passthrough().nullable().optional()
 }).passthrough();
 var IsometricTileSubmitSchema = z3.object({
   tile_id: z3.string().min(1),
@@ -1675,6 +1833,12 @@ var ProFlashImageSubmitSchema = z3.object({
   estimated_generations: z3.number().nullable().optional(),
   usage: z3.unknown().optional()
 }).passthrough();
+var VfxSubmitSchema = z3.object({
+  background_job_id: z3.string().min(1),
+  status: z3.string().default("processing"),
+  quoted_generations: z3.number().nullable().optional(),
+  usage: z3.unknown().optional()
+}).passthrough();
 var UnzoomResponseSchema = z3.object({
   image: z3.object({ base64: z3.string().min(1) }).passthrough(),
   original_size: z3.object({ width: z3.number().int(), height: z3.number().int() }).passthrough(),
@@ -2015,12 +2179,19 @@ var PixelLabClient = class {
       upper_description: args.upperDescription
     };
     if (args.transitionDescription) body.transition_description = args.transitionDescription;
+    if (args.lowerBaseTileId) body.lower_base_tile_id = args.lowerBaseTileId;
+    if (args.upperBaseTileId) body.upper_base_tile_id = args.upperBaseTileId;
     if (args.tileSize != null) body.tile_size = { width: args.tileSize, height: args.tileSize };
     if (args.mode) body.mode = args.mode;
     if (args.shapeStyle) body.shape_style = args.shapeStyle;
     if (args.spreadX != null) body.spread_x = args.spreadX;
     if (args.slopeSize != null) body.slope_size = args.slopeSize;
     if (args.raggedness != null) body.raggedness = args.raggedness;
+    if (args.roundness != null) body.roundness = args.roundness;
+    if (args.boundaryAmplitude != null) body.boundary_amplitude = args.boundaryAmplitude;
+    if (args.boundarySeed != null) body.boundary_seed = args.boundarySeed;
+    if (args.stepSlope != null) body.step_slope = args.stepSlope;
+    if (args.connectDiagonals != null) body.connect_diagonals = args.connectDiagonals;
     if (args.transitionSize != null) body.transition_size = args.transitionSize;
     if (args.view) body.view = args.view;
     if (args.outline) body.outline = args.outline;
@@ -2033,14 +2204,48 @@ var PixelLabClient = class {
       "create tileset"
     );
   }
-  /** Throws PixelLabError(423) while the set is still drawing; see Tileset. */
+  /**
+   * `/create-tileset-sidescroller`: a platform set seen from the side. One
+   * terrain (`lower_description`, the platform body) and the decorative
+   * layer on top of it (`transition_description`); the other side of every
+   * edge is empty air, so there is no upper description, mode, view, or
+   * shape control. 16 or 32px tiles only. The result is read through
+   * `getTileset` like a top-down set.
+   */
+  async createTilesetSidescroller(args) {
+    const body = { lower_description: args.lowerDescription };
+    if (args.transitionDescription) body.transition_description = args.transitionDescription;
+    if (args.lowerBaseTileId) body.lower_base_tile_id = args.lowerBaseTileId;
+    if (args.tileSize != null) body.tile_size = { width: args.tileSize, height: args.tileSize };
+    if (args.transitionSize != null) body.transition_size = args.transitionSize;
+    if (args.outline) body.outline = args.outline;
+    if (args.shading) body.shading = args.shading;
+    if (args.detail) body.detail = args.detail;
+    if (args.seed != null) body.seed = args.seed;
+    return validateResponse(
+      TilesetSubmitSchema,
+      await this.request("/create-tileset-sidescroller", { method: "POST", body: JSON.stringify(body) }),
+      "create sidescroller tileset"
+    );
+  }
+  /**
+   * Throws PixelLabError(423) while the set is still drawing; see Tileset.
+   * Serves top-down and sidescroller sets alike.
+   */
   async getTileset(tilesetId) {
     const res = await validateResponse(
       TilesetGetSchema,
       await this.request(`/tilesets/${tilesetId}`),
       "get tileset"
     );
-    return { tileset: res.tileset, usage: res.usage ?? null };
+    return {
+      tileset: res.tileset,
+      usage: res.usage ?? null,
+      metadata: {
+        terrainIds: res.metadata?.terrain_ids ?? {},
+        view: res.metadata?.view ?? null
+      }
+    };
   }
   /** A single standalone isometric tile — no connectable set, no candidates. */
   async createIsometricTile(args) {
@@ -2577,6 +2782,13 @@ var PixelLabClient = class {
    *
    * Reference images and a style image (`reference_images`, `style_image` +
    * `style_options`) exist on this endpoint but are not modeled here yet.
+   *
+   * `targetPalette` is the beta `target_palette` (PixelLab 0.4.130): with
+   * `colors`, the image is drawn for them and every result pixel is one of
+   * them; `name` ("PICO-8") helps the look; `maxColors` caps the colours in
+   * each candidate. Its `smart` flag is not modeled: it is documented as
+   * "single images only", and this endpoint returns a grid of candidates
+   * below 171px.
    */
   async createImagePro(args) {
     const body = {
@@ -2585,6 +2797,14 @@ var PixelLabClient = class {
     };
     if (args.noBackground != null) body.no_background = args.noBackground;
     if (args.seed != null) body.seed = args.seed;
+    const palette = args.targetPalette;
+    if (palette && (palette.colors?.length || palette.maxColors != null)) {
+      body.target_palette = {
+        ...palette.colors?.length ? { colors: palette.colors } : {},
+        ...palette.name ? { name: palette.name } : {},
+        ...palette.maxColors != null ? { max_colors: palette.maxColors } : {}
+      };
+    }
     return validateResponse(
       RevisionJobSubmitSchema,
       await this.request("/generate-image-v2", { method: "POST", body: JSON.stringify(body) }),
@@ -2775,6 +2995,27 @@ var PixelLabClient = class {
     );
     return { png: Buffer.from(res.image.base64, "base64"), usage: res.usage };
   }
+  /**
+   * `/normal-map` (PixelLab 0.4.130): the normal map of a sprite, so a game
+   * engine can light it. RGB is the way each pixel faces, alpha is 255 where
+   * the sprite shows and 0 elsewhere, at the input's size. An animation goes
+   * as one horizontal strip of `frames` equal frames (up to 32, each 8 to 512
+   * px per side) and comes back as a strip, planned once on the first frame
+   * so the light stays steady. `opengl` (the default) is green up, for
+   * Godot, Unity, and Phaser; `directx` is green down, for Unreal. A
+   * background job whose map is `last_response.image`; 0.5 generation,
+   * charged only when the map is delivered.
+   */
+  async normalMap(args) {
+    const body = { image: args.image };
+    if (args.frames != null && args.frames !== 1) body.frames = args.frames;
+    if (args.convention) body.convention = args.convention;
+    return validateResponse(
+      RevisionJobSubmitSchema,
+      await this.request("/normal-map", { method: "POST", body: JSON.stringify(body) }),
+      "normal-map"
+    );
+  }
   /**
    * `/unzoom`: recover native-resolution pixel art from an upscaled image (a
    * 32x32 sprite saved at 512x512). Synchronous like the Cleanup tier.
@@ -2865,6 +3106,28 @@ var PixelLabClient = class {
       "generate-font-pro"
     );
   }
+  /**
+   * `POST /vfx`: PixelLab's effects artist builds an animated effect from a
+   * description, around an optional sprite, and saves it to My effects. With
+   * `effectId` it changes that saved effect in place; adding the effect's
+   * `conversation` prices the change as a change. A background job whose
+   * 202 carries `quoted_generations`; PixelLab bills on delivery, up to
+   * twice the quote. A 503 (renderer busy) is retried by the shared policy.
+   */
+  async createVfx(args) {
+    const body = { description: args.description };
+    if (args.artist) body.artist = args.artist;
+    if (args.sprite) body.sprite = { type: "base64", base64: args.sprite.base64, format: args.sprite.format };
+    if (args.effectId) body.effect_id = args.effectId;
+    if (args.conversation) body.conversation = args.conversation;
+    if (args.name) body.name = args.name;
+    if (args.gamePack) body.game_pack = true;
+    return validateResponse(
+      VfxSubmitSchema,
+      await this.request("/vfx", { method: "POST", body: JSON.stringify(body) }),
+      "vfx"
+    );
+  }
   /** `GET /generate-font-pro/{job_id}`: status, then no-auth atlas and `.ttf` URLs once completed. */
   async getFontJob(jobId) {
     const raw = await this.request(`/generate-font-pro/${encodeURIComponent(jobId)}`);
@@ -3464,6 +3727,41 @@ function parseHex(hex2) {
   const n = parseInt(m[1], 16);
   return { r: n >> 16 & 255, g: n >> 8 & 255, b: n & 255 };
 }
+function joinStripPng(frames) {
+  const decoded = frames.map((frame) => decodePng(frame));
+  const first = decoded[0];
+  if (!first) throw new Error("a strip needs at least one frame");
+  const { width, height } = first;
+  for (const [index, frame] of decoded.entries()) {
+    if (frame.width !== width || frame.height !== height) {
+      throw new Error(`strip frame ${index} is ${frame.width}x${frame.height}; frame 0 is ${width}x${height}`);
+    }
+  }
+  const stride = width * 4;
+  const out = Buffer.alloc(stride * decoded.length * height);
+  for (let y = 0; y < height; y++) {
+    for (const [index, frame] of decoded.entries()) {
+      frame.pixels.copy(out, (y * decoded.length + index) * stride, y * stride, (y + 1) * stride);
+    }
+  }
+  return encodeRgbaPng(width * decoded.length, height, out);
+}
+function splitStripPng(strip, frames) {
+  const image = decodePng(strip);
+  if (frames < 1 || image.width % frames !== 0) {
+    throw new Error(`a ${image.width}x${image.height} strip does not split into ${frames} equal frames`);
+  }
+  const width = image.width / frames;
+  const stride = width * 4;
+  return Array.from({ length: frames }, (_, index) => {
+    const out = Buffer.alloc(stride * image.height);
+    for (let y = 0; y < image.height; y++) {
+      const from = (y * image.width + index * width) * 4;
+      image.pixels.copy(out, y * stride, from, from + stride);
+    }
+    return encodeRgbaPng(width, image.height, out);
+  });
+}
 
 // src/media.ts
 var MediaType = {
@@ -3579,10 +3877,10 @@ function imageMetadata(buf) {
 }
 
 // src/providers/pixellab.ts
-import { mkdirSync, existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { mkdirSync, existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
 import { randomUUID } from "crypto";
 import os from "os";
-import path2 from "path";
+import path3 from "path";
 
 // src/hash.ts
 import { createHash } from "crypto";
@@ -3618,6 +3916,9 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
       detail: effect ? void 0 : spec.detail ?? null,
       seed: effect ? void 0 : spec.seed ?? null,
       palette: effect ? void 0 : spec.palette,
+      // `imagePro` only, and absent unless the style sets them.
+      paletteName: spec.paletteName,
+      maxColors: spec.maxColors,
       // `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
@@ -3632,6 +3933,25 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
       uiPieces: spec.uiPieces,
       uiElements: spec.uiElements,
       uiColorPalette: spec.uiColorPalette,
+      // The older terrain knobs (terrainMode, terrainTransitionSize, and the
+      // rest) were never part of this hash, and adding them now would make
+      // every existing terrain entry stale. The Pro shape controls added
+      // after them are identity, each only when set.
+      terrainRoundness: spec.terrainRoundness,
+      terrainBoundaryAmplitude: spec.terrainBoundaryAmplitude,
+      terrainBoundarySeed: spec.terrainBoundarySeed,
+      terrainStepSlope: spec.terrainStepSlope,
+      terrainConnectDiagonals: spec.terrainConnectDiagonals,
+      // "top-down" is the default and draws the same set as leaving it out.
+      terrainOrientation: spec.terrainOrientation === "sidescroller" ? spec.terrainOrientation : void 0,
+      // Which set and which of its terrains, not that terrain's id: the id
+      // is in the lockfile, and the plan compares it there (like a mirror).
+      terrainConnect: spec.terrainConnect ? Object.fromEntries(
+        ["lower", "upper"].flatMap((side) => {
+          const link = spec.terrainConnect[side];
+          return link ? [[side, { of: link.assetId, terrain: link.terrain }]] : [];
+        })
+      ) : void 0,
       // Scene and mask enter as their bytes' hashes, never their paths.
       scene: spec.scene ? {
         image: spec.scene.sha256,
@@ -3693,13 +4013,17 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
         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.
+      // their paths; the My effects name is not identity. `description` and
+      // `artist` exist only for the paid VFX artist and stay absent for a
+      // workbench effect, so its hash is the one it always had.
       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
+        sprite: spec.vfx.sprite ? "reference" in spec.vfx.sprite ? spec.vfx.sprite.reference : spec.vfx.sprite.sha256 : void 0,
+        description: spec.vfx.description,
+        artist: spec.vfx.description ? spec.vfx.artist : 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.
@@ -3729,6 +4053,7 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
         skeletonTemplate: spec.revision.skeletonTemplate,
         description: spec.revision.description,
         removalTask: spec.revision.removalTask,
+        convention: spec.revision.convention,
         driftThreshold: spec.revision.driftThreshold,
         subjectDescription: spec.revision.subjectDescription,
         initialPose: spec.revision.initialPose,
@@ -3875,7 +4200,8 @@ function vfxOutputPaths(out) {
     gif: `${base}.gif`,
     atlas: `${base}.json`,
     provenance: `${base}.vfx.json`,
-    gamePack: `${base}-game.zip`
+    gamePack: `${base}-game.zip`,
+    normals: `${base}-normals.png`
   };
 }
 function isVfxReference(sprite) {
@@ -3965,10 +4291,17 @@ function vfxRecipeSha256(recipe) {
   const { name: _name, notes: _notes, ...rest } = recipe;
   return sha256(JSON.stringify(rest));
 }
+function vfxAtlasFrames(atlas) {
+  const listed = atlas?.frames;
+  const entries = Array.isArray(listed) ? listed : listed && typeof listed === "object" ? Object.values(listed) : null;
+  if (!entries?.length) return null;
+  const rects = entries.map((entry) => entry?.frame);
+  return rects.every((rect) => rect && [rect.x, rect.y, rect.w, rect.h].every((n) => typeof n === "number")) ? rects : null;
+}
 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 listed = vfxAtlasFrames(atlas);
+  const rects = listed && listed.length === facts.frames ? listed : 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 };
   });
@@ -4068,6 +4401,477 @@ async function makeVfx(client2, opts) {
 `);
   return { ...exported, paths: written, recipe };
 }
+var VFX_ARTISTS = ["lite", "pro"];
+var VFX_ARTIST_MAX_SPRITE = 512;
+function vfxArtistQuote(artist, sprite, change = false) {
+  const table = {
+    lite: { new: [1, 1, 3, 5], change: [1, 1, 2, 2] },
+    pro: { new: [6, 8, 14, 28], change: [4, 4, 5, 8] }
+  };
+  const tier = sprite === "none" ? 0 : sprite === "unknown" ? 3 : sprite <= 128 ? 1 : sprite <= 256 ? 2 : 3;
+  return table[artist][change ? "change" : "new"][tier];
+}
+function vfxArtistCeiling(quote) {
+  return quote * 2;
+}
+function vfxArtistSprite(bytes, label) {
+  const metadata = imageMetadata(bytes);
+  if (metadata?.format !== "png") throw new Error(`${label}: PixelLab's VFX artist takes a PNG sprite`);
+  const side = Math.max(metadata.width, metadata.height);
+  if (side > VFX_ARTIST_MAX_SPRITE) {
+    throw new Error(
+      `${label} is ${metadata.width}x${metadata.height}; PixelLab's VFX artist takes up to ${VFX_ARTIST_MAX_SPRITE}x${VFX_ARTIST_MAX_SPRITE} (crop or pad it; never rescale pixel art)`
+    );
+  }
+  return { image: { base64: bytes.toString("base64"), format: "png" }, side };
+}
+function vfxArtistFiles(raw) {
+  const urlOf = (value) => {
+    if (typeof value === "string") return /^https?:\/\//i.test(value) ? value : null;
+    if (!value || typeof value !== "object") return null;
+    for (const key of ["url", "download_url", "href"]) {
+      const url = value[key];
+      if (typeof url === "string" && /^https?:\/\//i.test(url)) return url;
+    }
+    return null;
+  };
+  const nameOf = (value, url, key) => {
+    if (value && typeof value === "object") {
+      for (const field of ["name", "filename", "file"]) {
+        const name = value[field];
+        if (typeof name === "string" && name) return name;
+      }
+    }
+    if (key && /\.[a-z0-9]+$/i.test(key)) return key;
+    return decodeURIComponent(new URL(url).pathname.split("/").pop() ?? "");
+  };
+  const entries = Array.isArray(raw) ? raw.map((value) => [void 0, value]) : raw && typeof raw === "object" ? Object.entries(raw) : [];
+  const files = [];
+  for (const [key, value] of entries) {
+    const url = urlOf(value);
+    if (url) files.push({ name: nameOf(value, url, key), url });
+  }
+  return files;
+}
+function parseVfxArtistResult(done, jobId) {
+  const files = vfxArtistFiles(done.files);
+  const pick = (test, skip) => files.find((file) => test.test(file.name) && !skip?.test(file.name)) ?? null;
+  const normals = /-normals?\.png$/i;
+  const sheet = pick(/\.png$/i, normals);
+  const effectId = typeof done.effect_id === "string" && done.effect_id ? done.effect_id : null;
+  if (!effectId || !sheet) {
+    throw new Error(
+      `Invalid PixelLab response for vfx job ${jobId}: completed without ${effectId ? "a spritesheet among its files" : "an effect_id"} (last_response keys: ${Object.keys(done).join(", ") || "none"}; files: ${JSON.stringify(done.files ?? null).slice(0, 400)}); update parseVfxArtistResult in src/pixellab-vfx.ts with the real shape`
+    );
+  }
+  const number = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+  const text = (value) => typeof value === "string" && value ? value : null;
+  const canvas = done.canvas ?? {};
+  const anchor = done.anchor;
+  return {
+    effectId,
+    name: text(done.name),
+    editUrl: text(done.edit_url),
+    message: text(done.message),
+    width: number(canvas.w),
+    height: number(canvas.h),
+    frames: number(done.frames),
+    fps: number(done.fps),
+    loop: typeof done.loop === "boolean" ? done.loop : null,
+    anchor: anchor && number(anchor.x) !== null && number(anchor.y) !== null ? { kind: text(anchor.kind), x: anchor.x, y: anchor.y } : null,
+    parts: done.parts ?? null,
+    conversation: text(done.conversation),
+    files,
+    sheet,
+    atlas: pick(/\.json$/i),
+    gif: pick(/\.gif$/i),
+    gamePack: pick(/\.zip$/i),
+    normals: pick(normals)
+  };
+}
+function vfxArtistFrameFacts(result, atlas) {
+  const rects = vfxAtlasFrames(atlas);
+  const frames = result.frames ?? rects?.length ?? null;
+  const width = result.width ?? rects?.[0]?.w ?? null;
+  const height = result.height ?? rects?.[0]?.h ?? null;
+  if (!frames || !width || !height) {
+    throw new Error(`PixelLab vfx effect ${result.effectId} came back with no frame size or count, in the result or its atlas`);
+  }
+  return { width, height, frames };
+}
+async function makeVfxWithArtist(client2, opts) {
+  const paths = vfxOutputPaths(opts.out);
+  if (!opts.force) {
+    for (const file of [paths.sheet, paths.gif, paths.atlas, paths.provenance, ...opts.gamePack ? [paths.gamePack] : []]) {
+      if (existsSync(file)) throw new Error(`${file} already exists; pass --force to replace it`);
+    }
+  }
+  const progress = opts.onProgress ?? (() => {
+  });
+  const sprite = opts.sprite ? vfxArtistSprite(await readFile(opts.sprite), opts.sprite).image : void 0;
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const interval = opts.intervalMs ?? 6e3;
+  const timeout = opts.timeoutMs ?? 10 * 6e4;
+  const submitted = await client2.createVfx({
+    description: opts.description,
+    artist: opts.artist,
+    sprite,
+    effectId: opts.effect,
+    conversation: opts.effect ? opts.conversation : void 0,
+    name: opts.name,
+    gamePack: opts.gamePack
+  });
+  const jobId = submitted.background_job_id;
+  progress(`submitted job ${jobId}, quoted ${submitted.quoted_generations ?? "?"} generations`);
+  const started = Date.now();
+  let job;
+  for (; ; ) {
+    job = await client2.getBackgroundJob(jobId);
+    if (job.status === "completed") break;
+    if (job.status === "failed") throw new Error(`PixelLab vfx job ${jobId} failed upstream${vfxJobFailure(job.last_response)}`);
+    if (Date.now() - started > timeout) {
+      throw new Error(
+        `PixelLab vfx job ${jobId} is still ${job.status} after ${Math.round(timeout / 1e3)} s; it keeps running upstream (and bills when delivered), but this command has stopped waiting`
+      );
+    }
+    progress(job.status);
+    await sleep3(interval);
+  }
+  const result = parseVfxArtistResult(job.last_response ?? {}, jobId);
+  await mkdir(path.dirname(paths.sheet), { recursive: true });
+  const written = { sheet: paths.sheet, provenance: paths.provenance };
+  await writeFile(paths.sheet, await client2.download(result.sheet.url));
+  let atlas;
+  if (result.atlas) {
+    atlas = JSON.parse((await client2.download(result.atlas.url)).toString("utf8"));
+    const meta = atlas.meta;
+    if (meta) meta.image = path.basename(paths.sheet);
+    await writeFile(paths.atlas, `${JSON.stringify(atlas, null, 2)}
+`);
+    written.atlas = paths.atlas;
+  }
+  for (const [file, target, key] of [
+    [result.gif, paths.gif, "gif"],
+    [result.gamePack, paths.gamePack, "gamePack"],
+    [result.normals, paths.normals, "normals"]
+  ]) {
+    if (!file) continue;
+    await writeFile(target, await client2.download(file.url));
+    written[key] = target;
+  }
+  const facts = vfxArtistFrameFacts(result, atlas);
+  const usage = job.usage ?? null;
+  const provenance = {
+    version: 1,
+    provider: "pixellab",
+    tool: "vfx",
+    artist: opts.artist ?? "lite",
+    description: opts.description,
+    name: result.name,
+    effectId: result.effectId,
+    editUrl: result.editUrl,
+    message: result.message,
+    source: {
+      ...opts.sprite ? { sprite: path.relative(path.dirname(paths.provenance), path.resolve(opts.sprite)).split(path.sep).join("/") } : {},
+      ...opts.effect ? { changed: opts.effect } : {}
+    },
+    ...facts,
+    fps: result.fps,
+    loop: result.loop,
+    anchor: result.anchor,
+    parts: result.parts,
+    files: Object.fromEntries(
+      ["sheet", "gif", "atlas", "gamePack", "normals"].filter((key) => written[key]).map((key) => [key, path.basename(written[key])])
+    ),
+    quotedGenerations: submitted.quoted_generations ?? null,
+    usage,
+    conversation: result.conversation,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeFile(paths.provenance, `${JSON.stringify(provenance, null, 2)}
+`);
+  return {
+    jobId,
+    effectId: result.effectId,
+    editUrl: result.editUrl,
+    name: result.name,
+    message: result.message,
+    ...facts,
+    fps: result.fps,
+    loop: result.loop,
+    anchor: result.anchor,
+    quotedGenerations: submitted.quoted_generations ?? null,
+    usage,
+    paths: written
+  };
+}
+function vfxJobFailure(done) {
+  for (const key of ["error", "detail", "message"]) {
+    const value = done?.[key];
+    if (typeof value === "string" && value) return `: ${value}`;
+  }
+  return "";
+}
+async function readVfxConversation(file, effectId) {
+  if (!existsSync(file)) return void 0;
+  try {
+    const record = JSON.parse(await readFile(file, "utf8"));
+    return record.effectId === effectId && typeof record.conversation === "string" ? record.conversation : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/source-url.ts
+var SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "access_token",
+  "apikey",
+  "api_key",
+  "auth",
+  "authorization",
+  "awsaccesskeyid",
+  "googleaccessid",
+  "key",
+  "sig"
+]);
+function isSensitiveSourceUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return false;
+  }
+  if (parsed.username || parsed.password) return true;
+  for (const key of parsed.searchParams.keys()) {
+    const normalized = key.toLowerCase();
+    if (SENSITIVE_QUERY_KEYS.has(normalized) || normalized.includes("credential") || normalized.includes("signature") || normalized.includes("security-token") || normalized.includes("token")) return true;
+  }
+  return false;
+}
+function shouldPersistSourceUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return true;
+  }
+  if (parsed.protocol === "data:" || parsed.protocol === "file:") return false;
+  return !isSensitiveSourceUrl(value);
+}
+
+// src/pixellab-utils.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+var UNZOOM_MIN_SIDE = 256;
+var UNZOOM_MAX_AREA = 2048 * 2048;
+function defaultUnzoomOut(input) {
+  const ext = path2.extname(input);
+  return `${ext ? input.slice(0, -ext.length) : input}.unzoomed.png`;
+}
+async function unzoomFile(client2, input, opts = {}) {
+  const out = path2.resolve(opts.out ?? defaultUnzoomOut(input));
+  if (path2.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
+  if (existsSync2(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
+  const bytes = await readFile2(input);
+  const metadata = imageMetadata(bytes);
+  if (!metadata) throw new Error(`${input} is not a readable PNG or JPEG`);
+  const { width, height, format } = metadata;
+  if (width < UNZOOM_MIN_SIDE || height < UNZOOM_MIN_SIDE) {
+    throw new Error(
+      `${input} is ${width}x${height}; PixelLab's unzoom needs at least ${UNZOOM_MIN_SIDE}x${UNZOOM_MIN_SIDE} to find the pixel grid, so this is probably already at its native size`
+    );
+  }
+  if (width * height > UNZOOM_MAX_AREA) {
+    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 mkdir2(path2.dirname(out), { recursive: true });
+  await writeFile2(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 = path2.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 (existsSync2(file)) throw new Error(`${file} already exists; pass --force to replace it`);
+    }
+  }
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const interval = opts.intervalMs ?? 5e3;
+  const timeout = opts.timeoutMs ?? 10 * 6e4;
+  const submitted = await client2.generateFontPro({
+    description: opts.description,
+    weight: opts.weight,
+    glyphPx: opts.glyphPx,
+    seed: opts.seed,
+    fontName: opts.fontName
+  });
+  const jobId = submitted.background_job_id;
+  const started = Date.now();
+  for (; ; ) {
+    const job = await client2.getFontJob(jobId);
+    opts.onProgress?.(job.status);
+    if (job.status === "failed") throw new Error(`PixelLab font job ${jobId} failed upstream`);
+    if (job.status === "completed") {
+      if (!job.download_ttf_url || !job.download_atlas_url) {
+        throw new Error(`PixelLab font job ${jobId} completed without both download URLs`);
+      }
+      const [ttfBytes, atlasBytes] = await Promise.all([
+        client2.download(job.download_ttf_url),
+        client2.download(job.download_atlas_url)
+      ]);
+      await mkdir2(path2.dirname(ttf), { recursive: true });
+      await writeFile2(ttf, ttfBytes);
+      await writeFile2(atlas, atlasBytes);
+      return { jobId, ttf, atlas, glyphPx: job.glyph_px ?? null, usage: job.usage };
+    }
+    if (Date.now() - started > timeout) {
+      throw new Error(
+        `PixelLab font job ${jobId} is still ${job.status} after ${Math.round(timeout / 1e3)} s; it keeps running upstream, but this command has stopped waiting`
+      );
+    }
+    await sleep3(interval);
+  }
+}
+var PIXELATE_COST_GENERATIONS = 6;
+var PIXELATE_MAX_SIDE = 2048;
+function defaultPixelateOut(input) {
+  const ext = path2.extname(input);
+  return `${ext ? input.slice(0, -ext.length) : input}.pixel.png`;
+}
+async function pixelateFile(client2, input, opts = {}) {
+  const out = path2.resolve(opts.out ?? defaultPixelateOut(input));
+  if (path2.resolve(input) === out) throw new Error("pixelate will not overwrite its own input; pass a different --out");
+  if (existsSync2(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
+  const bytes = await readFile2(input);
+  const metadata = imageMetadata(bytes);
+  if (!metadata) throw new Error(`${input} is not a readable PNG or JPEG`);
+  const { width, height, format } = metadata;
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const interval = opts.intervalMs ?? 5e3;
+  const timeout = opts.timeoutMs ?? 10 * 6e4;
+  const submitted = await client2.imageToPixelartProFlash({
+    image: { base64: bytes.toString("base64"), format },
+    description: opts.description,
+    seed: opts.seed
+  });
+  const jobId = submitted.background_job_id;
+  const started = Date.now();
+  for (; ; ) {
+    const job = await client2.getBackgroundJob(jobId);
+    opts.onProgress?.(job.status);
+    if (job.status === "failed") throw new Error(`PixelLab pixelate job ${jobId} failed upstream`);
+    if (job.status === "completed") {
+      const images = job.last_response?.images;
+      const first = Array.isArray(images) ? images[0] : void 0;
+      if (!first || typeof first.base64 !== "string" || !first.base64) {
+        throw new Error(`PixelLab pixelate job ${jobId} completed without an image at last_response.images[0]`);
+      }
+      const png = Buffer.from(first.base64, "base64");
+      const size = imageMetadata(png);
+      await mkdir2(path2.dirname(out), { recursive: true });
+      await writeFile2(out, png);
+      return {
+        jobId,
+        out,
+        original: { width, height },
+        pixelated: { width: size?.width ?? Number(first.width), height: size?.height ?? Number(first.height) },
+        imageId: submitted.image_id,
+        usage: job.usage ?? null
+      };
+    }
+    if (Date.now() - started > timeout) {
+      throw new Error(
+        `PixelLab pixelate job ${jobId} is still ${job.status} after ${Math.round(timeout / 1e3)} s; it keeps running upstream, but this command has stopped waiting`
+      );
+    }
+    await sleep3(interval);
+  }
+}
+var NORMAL_MAP_COST_GENERATIONS = 0.5;
+var NORMAL_MAP_MIN_SIDE = 8;
+var NORMAL_MAP_MAX_SIDE = 512;
+var NORMAL_MAP_MAX_FRAMES = 32;
+var NORMAL_MAP_CONVENTIONS = ["opengl", "directx"];
+function normalMapSizeProblem(width, height, frames = 1) {
+  if (!Number.isInteger(frames) || frames < 1 || frames > NORMAL_MAP_MAX_FRAMES) {
+    return `PixelLab's normal map takes 1 to ${NORMAL_MAP_MAX_FRAMES} frames, not ${frames}`;
+  }
+  if (width % frames !== 0) return `a ${width}px-wide strip does not split into ${frames} equal frames`;
+  const frameWidth = width / frames;
+  if (frameWidth < NORMAL_MAP_MIN_SIDE || height < NORMAL_MAP_MIN_SIDE || frameWidth > NORMAL_MAP_MAX_SIDE || height > NORMAL_MAP_MAX_SIDE) {
+    return `${frames > 1 ? "each frame is " : "it is "}${frameWidth}x${height}; PixelLab's normal map takes ${NORMAL_MAP_MIN_SIDE} to ${NORMAL_MAP_MAX_SIDE} px per side`;
+  }
+  return null;
+}
+function defaultNormalMapOut(input) {
+  const ext = path2.extname(input);
+  return `${ext ? input.slice(0, -ext.length) : input}.normal.png`;
+}
+function normalMapResultPng(lastResponse) {
+  const image = lastResponse?.image;
+  const base64 = typeof image === "string" ? image : image?.base64;
+  if (typeof base64 !== "string" || !base64) return null;
+  return Buffer.from(base64.replace(/^data:image\/\w+;base64,/, ""), "base64");
+}
+async function normalMapFile(client2, input, opts = {}) {
+  const out = path2.resolve(opts.out ?? defaultNormalMapOut(input));
+  if (path2.resolve(input) === out) throw new Error("normal-map will not overwrite its own input; pass a different --out");
+  if (existsSync2(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
+  const bytes = await readFile2(input);
+  const metadata = imageMetadata(bytes);
+  if (!metadata) throw new Error(`${input} is not a readable PNG or JPEG`);
+  if (metadata.format !== "png") throw new Error(`${input} is a JPEG; normal-map reads a PNG, whose alpha marks where the sprite is`);
+  const { width, height } = metadata;
+  const frames = opts.frames ?? 1;
+  const problem = normalMapSizeProblem(width, height, frames);
+  if (problem) throw new Error(`${input}: ${problem}`);
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const interval = opts.intervalMs ?? 5e3;
+  const timeout = opts.timeoutMs ?? 10 * 6e4;
+  const submitted = await client2.normalMap({
+    image: { base64: bytes.toString("base64"), format: "png" },
+    frames,
+    convention: opts.convention
+  });
+  const jobId = submitted.background_job_id;
+  const started = Date.now();
+  for (; ; ) {
+    const job = await client2.getBackgroundJob(jobId);
+    opts.onProgress?.(job.status);
+    if (job.status === "failed") throw new Error(`PixelLab normal-map job ${jobId} failed upstream`);
+    if (job.status === "completed") {
+      const png = normalMapResultPng(job.last_response);
+      if (!png) throw new Error(`PixelLab normal-map job ${jobId} completed without an image at last_response.image`);
+      await mkdir2(path2.dirname(out), { recursive: true });
+      await writeFile2(out, png);
+      const size = imageMetadata(png);
+      return {
+        jobId,
+        out,
+        width: size?.width ?? width,
+        height: size?.height ?? height,
+        frames,
+        convention: opts.convention ?? "opengl",
+        usage: job.usage ?? null
+      };
+    }
+    if (Date.now() - started > timeout) {
+      throw new Error(
+        `PixelLab normal-map job ${jobId} is still ${job.status} after ${Math.round(timeout / 1e3)} s; it keeps running upstream, but this command has stopped waiting`
+      );
+    }
+    await sleep3(interval);
+  }
+}
 
 // src/providers/pixellab.ts
 function pixelLabObjectUrl(generator, objectId) {
@@ -4086,6 +4890,20 @@ function pixelLabObjectUrl(generator, objectId) {
   if (generator === "vfx") return `https://pixellab.ai/create-vfx?effect=${encodeURIComponent(objectId)}`;
   return null;
 }
+function vfxArtistSpecQuote(spec) {
+  const sprite = spec.vfx?.sprite;
+  const side = !sprite ? "none" : "file" in sprite && sprite.width != null && sprite.height != null ? Math.max(sprite.width, sprite.height) : "unknown";
+  return vfxArtistQuote(spec.vfx?.artist ?? "lite", side);
+}
+function workbenchVfxUrls(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(", ")}`);
+  return {
+    sheet: `${exported.downloadBase}${encodeURIComponent(sheetFile)}`,
+    ...atlasFile ? { atlas: `${exported.downloadBase}${encodeURIComponent(atlasFile)}` } : {}
+  };
+}
 function billedFromUsage(usage) {
   if (!usage) return null;
   if (usage.type === "usd" || usage.type === void 0 && typeof usage.usd === "number") {
@@ -4240,13 +5058,14 @@ var PixelLabProvider = class _PixelLabProvider {
    * source from a supplied per-frame skeleton instead of a text description)
    * — and `interpolate` (`/interpolation-v2`, the in-betweens
    * from one keyframe to another) and `edit-animation`
-   * (`/edit-animation-v2`, one text edit applied across a whole frame set).
+   * (`/edit-animation-v2`, one text edit applied across a whole frame set),
+   * and `normal-map` (`/normal-map`, lighting data for a sprite or a loop).
    * `outpaint` does not: there is no canvas-expansion endpoint in the API,
    * matching docs/REVISIONS.md's note that no provider ships a tested
    * outpaint path yet.
    */
   supportsRevision(mode2) {
-    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "remove-background" || mode2 === "animate" || mode2 === "animate-pixminimax" || mode2 === "animate-skeleton" || mode2 === "interpolate" || mode2 === "edit-animation";
+    return mode2 === "inpaint" || mode2 === "image-to-image" || mode2 === "reduce-colors" || mode2 === "correct-pixelart" || mode2 === "remove-background" || mode2 === "normal-map" || mode2 === "animate" || mode2 === "animate-pixminimax" || mode2 === "animate-skeleton" || mode2 === "interpolate" || mode2 === "edit-animation";
   }
   /** PixelLab's own constraints: submissions must be >2s apart, and
    *  background jobs in flight are capped by subscription tier (Tier 1=8,
@@ -4266,11 +5085,12 @@ var PixelLabProvider = class _PixelLabProvider {
    * is a file read.
    */
   static cacheDir(namespace = "pixflux") {
-    const dir = path2.join(os.tmpdir(), `pixelkiln-${namespace}`);
+    const dir = path3.join(os.tmpdir(), `pixelkiln-${namespace}`);
     mkdirSync(dir, { recursive: true });
     return dir;
   }
   estimate(spec) {
+    if (spec.vfx?.description) return { unit: "generations", amount: vfxArtistCeiling(vfxArtistSpecQuote(spec)), candidates: 1 };
     if (spec.vfx) return { unit: "generations", amount: 0, candidates: 1 };
     if (spec.batch?.role === "member") {
       return { unit: "generations", amount: 0, candidates: 1 };
@@ -4278,6 +5098,9 @@ var PixelLabProvider = class _PixelLabProvider {
     if (spec.revision?.mode === "remove-background") {
       return { unit: "generations", amount: 1, candidates: 1 };
     }
+    if (spec.revision?.mode === "normal-map") {
+      return { unit: "generations", amount: NORMAL_MAP_COST_GENERATIONS, candidates: 1 };
+    }
     if (spec.revision?.mode === "reduce-colors" || spec.revision?.mode === "correct-pixelart") {
       return { unit: "generations", amount: 0.1, candidates: 1 };
     }
@@ -4332,12 +5155,40 @@ var PixelLabProvider = class _PixelLabProvider {
     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 sprite = spec.vfx?.description ? spec.vfx.sprite : void 0;
+    if (sprite && "reference" in sprite) {
+      throw new Error("PixelLab's VFX artist takes a sprite's pixels, not a PixelLab reference; point vfx.sprite at a PNG file");
+    }
+    if (sprite?.width != null && sprite.height != null && Math.max(sprite.width, sprite.height) > VFX_ARTIST_MAX_SPRITE) {
+      throw new Error(
+        `vfx sprite ${sprite.file} is ${sprite.width}x${sprite.height}; PixelLab's VFX artist takes up to ${VFX_ARTIST_MAX_SPRITE}x${VFX_ARTIST_MAX_SPRITE} (crop or pad it; never rescale pixel art)`
+      );
+    }
     const members = spec.revision?.sourceMembers;
     if (spec.revision && members && !MEMBER_SET_REVISION_MODES.includes(spec.revision.mode)) {
       throw new Error(
-        `PixelLab ${spec.revision.mode} reads one source image; ${spec.revision.sourceAssetId} is a ${members.length}-member set (${members[0].role}, ...). Revise one member through a declared source, or use reduce-colors, correct-pixelart, or edit-animation, which take the whole set`
+        `PixelLab ${spec.revision.mode} reads one source image; ${spec.revision.sourceAssetId} is a ${members.length}-member set (${members[0].role}, ...). Revise one member through a declared source, or use reduce-colors, correct-pixelart, edit-animation, or normal-map, which take the whole set`
       );
     }
+    if (spec.revision?.mode === "normal-map") {
+      const { sourceWidth: width, sourceHeight: height, sourceFormat, sourceAssetId } = spec.revision;
+      if (members && !members.every((member) => member.role.startsWith("frame-"))) {
+        throw new Error(
+          `PixelLab normal-map reads one sprite or one animation loop; ${sourceAssetId} is a set of directions (${members.map((member) => member.role).join(", ")}). Make one normal-map revision per direction, each from an asset whose \`source\` is that direction's file`
+        );
+      }
+      if (members && members.length > NORMAL_MAP_MAX_FRAMES) {
+        throw new Error(
+          `PixelLab normal-map takes at most ${NORMAL_MAP_MAX_FRAMES} frames in one strip; ${sourceAssetId} has ${members.length}`
+        );
+      }
+      if (sourceFormat === "jpeg") {
+        throw new Error(`PixelLab normal-map reads a PNG, whose alpha marks where the sprite is; ${sourceAssetId} is a JPEG`);
+      }
+      const frames = members?.length ?? 1;
+      const problem = width != null && height != null ? normalMapSizeProblem(width * frames, height, frames) : null;
+      if (problem) throw new Error(`PixelLab normal-map source ${sourceAssetId}: ${problem}`);
+    }
     if (spec.revision?.engine === "pro-flash") {
       const { sourceWidth: width, sourceHeight: height, mode: mode2 } = spec.revision;
       if (width != null && height != null && (width < 32 || height < 32 || width > 256 || height > 256 || width % 4 || height % 4)) {
@@ -4445,6 +5296,9 @@ var PixelLabProvider = class _PixelLabProvider {
         `PixelLab imagePro is ${spec.width}x${spec.height}; the API takes 16 to 792 wide and 16 to 688 tall (the exact ceiling also depends on aspect ratio)`
       );
     }
+    if (spec.generator === "imagePro" && !spec.revision && spec.palette.length && (spec.palette.length < 2 || spec.palette.length > 256)) {
+      throw new Error(`PixelLab imagePro's target palette takes 2 to 256 colours; the style's palette has ${spec.palette.length}`);
+    }
     if (spec.generator === "uiAsset" && (spec.width < 192 || spec.height < 192 || spec.width > 688 || spec.height > 688)) {
       throw new Error(
         `PixelLab uiAsset is ${spec.width}x${spec.height}; the API takes 192 to 688 pixels per side (the exact ceiling also depends on aspect ratio \u2014 square tops out at 512, 16:9 at 688x384, 9:16 at 384x688, 4:3 at 600x448, 3:4 at 448x600)`
@@ -4511,24 +5365,8 @@ var PixelLabProvider = class _PixelLabProvider {
       if (spec.detail) {
         requirePixelLabOption("terrain", "detail", spec.detail, ["low detail", "medium detail", "highly detailed"]);
       }
-      if (spec.terrainShapeStyle && spec.terrainMode === "pro") {
-        throw new Error(
-          "PixelLab terrain: terrainShapeStyle is standard-mode only; pro's own shape controls are terrainSpreadX/terrainSlopeSize/terrainRaggedness"
-        );
-      }
-      if (spec.terrainTileSize === 64 && spec.terrainMode !== "pro") {
-        throw new Error('PixelLab terrain: a 64px tile needs terrainMode: "pro"');
-      }
-      if (spec.terrainShapeStyle && spec.terrainTransitionSize != null && spec.terrainTransitionSize > 0.5) {
-        throw new Error(
-          "PixelLab terrain: terrainShapeStyle with terrainTransitionSize above 0.5 uses an extended 32-tile layout pixelkiln does not model; use 0, 0.25, or 0.5"
-        );
-      }
-      if (!spec.terrainShapeStyle && spec.terrainTransitionSize != null && ![0, 0.25, 0.5, 1].includes(spec.terrainTransitionSize)) {
-        throw new Error(
-          "PixelLab terrain: terrainTransitionSize must be 0, 0.25, 0.5, or 1 unless terrainShapeStyle is set"
-        );
-      }
+      if (spec.terrainOrientation === "sidescroller") this.validateSidescrollerTerrain(spec);
+      else this.validateTopDownTerrain(spec);
     }
     if (spec.generator === "isometricTile") {
       if (spec.outline) {
@@ -4587,6 +5425,87 @@ var PixelLabProvider = class _PixelLabProvider {
       );
     }
   }
+  /** `/create-tileset`'s own rules, beyond the enums both terrain endpoints share. */
+  validateTopDownTerrain(spec) {
+    if (spec.terrainShapeStyle && spec.terrainMode === "pro") {
+      throw new Error(
+        "PixelLab terrain: terrainShapeStyle is standard-mode only; pro's own shape controls are terrainRaggedness/terrainRoundness/terrainBoundaryAmplitude/terrainStepSlope"
+      );
+    }
+    const pro = spec.terrainMode === "pro";
+    if (spec.terrainRoundness != null && !pro && !spec.terrainShapeStyle) {
+      throw new Error('PixelLab terrain: terrainRoundness needs terrainMode: "pro" or a terrainShapeStyle');
+    }
+    if (spec.terrainRoundness != null && spec.terrainRoundness > 1 && !pro) {
+      throw new Error('PixelLab terrain: terrainRoundness above 1 (corners cut toward 45\xB0) needs terrainMode: "pro"');
+    }
+    if (spec.terrainBoundaryAmplitude != null && !pro && !spec.terrainShapeStyle) {
+      throw new Error('PixelLab terrain: terrainBoundaryAmplitude needs terrainMode: "pro" or a terrainShapeStyle');
+    }
+    if (spec.terrainBoundarySeed != null && spec.terrainBoundaryAmplitude == null) {
+      throw new Error("PixelLab terrain: terrainBoundarySeed shapes terrainBoundaryAmplitude's border; set both or neither");
+    }
+    if (spec.terrainStepSlope != null && !(pro && spec.terrainTransitionSize === 0.25)) {
+      throw new Error('PixelLab terrain: terrainStepSlope needs terrainMode: "pro" with terrainTransitionSize 0.25');
+    }
+    if (spec.terrainConnectDiagonals != null && !pro) {
+      throw new Error('PixelLab terrain: terrainConnectDiagonals needs terrainMode: "pro"');
+    }
+    if (spec.terrainTileSize === 64 && spec.terrainMode !== "pro") {
+      throw new Error('PixelLab terrain: a 64px tile needs terrainMode: "pro"');
+    }
+    if (spec.terrainShapeStyle && spec.terrainTransitionSize != null && spec.terrainTransitionSize > 0.5) {
+      throw new Error(
+        "PixelLab terrain: terrainShapeStyle with terrainTransitionSize above 0.5 uses an extended 32-tile layout pixelkiln does not model; use 0, 0.25, or 0.5"
+      );
+    }
+    if (!spec.terrainShapeStyle && spec.terrainTransitionSize != null && ![0, 0.25, 0.5, 1].includes(spec.terrainTransitionSize)) {
+      throw new Error(
+        "PixelLab terrain: terrainTransitionSize must be 0, 0.25, 0.5, or 1 unless terrainShapeStyle is set"
+      );
+    }
+  }
+  /**
+   * `/create-tileset-sidescroller` takes a platform, its top layer, and the
+   * layer's height, and nothing of the top-down endpoint's mode, camera, or
+   * shape controls; sending one would be silently dropped, so it is refused.
+   */
+  validateSidescrollerTerrain(spec) {
+    const topDownOnly = {
+      terrainMode: spec.terrainMode,
+      terrainShapeStyle: spec.terrainShapeStyle,
+      terrainView: spec.terrainView,
+      terrainSpreadX: spec.terrainSpreadX,
+      terrainSlopeSize: spec.terrainSlopeSize,
+      terrainRaggedness: spec.terrainRaggedness,
+      terrainRoundness: spec.terrainRoundness,
+      terrainBoundaryAmplitude: spec.terrainBoundaryAmplitude,
+      terrainBoundarySeed: spec.terrainBoundarySeed,
+      terrainStepSlope: spec.terrainStepSlope,
+      terrainConnectDiagonals: spec.terrainConnectDiagonals
+    };
+    const set = Object.entries(topDownOnly).filter(([, value]) => value != null).map(([field]) => field);
+    if (set.length) {
+      throw new Error(`PixelLab terrain: a sidescroller set takes no ${set.join(", ")}; those are top-down controls`);
+    }
+    if (spec.terrainTileSize !== 16 && spec.terrainTileSize !== 32) {
+      throw new Error(`PixelLab terrain: a sidescroller set's tiles are 16 or 32px, got ${spec.terrainTileSize}`);
+    }
+    if (spec.terrainTransitionSize != null && ![0, 0.25, 0.5, 1].includes(spec.terrainTransitionSize)) {
+      throw new Error("PixelLab terrain: a sidescroller set's terrainTransitionSize must be 0, 0.25, 0.5, or 1");
+    }
+    if (spec.terrainConnect?.upper) {
+      throw new Error(
+        "PixelLab terrain: a sidescroller set's upper terrain is empty air; only its lower (platform) terrain can connect"
+      );
+    }
+    const link = spec.terrainConnect?.lower;
+    if (link?.terrain === "upper") {
+      throw new Error(
+        `PixelLab terrain: ${link.assetId}'s upper terrain is empty air; connect to its lower (platform) terrain`
+      );
+    }
+  }
   validateCharacter(spec, styleImages = []) {
     const character = spec.character;
     if (!character) throw new Error(`${spec.styleId}/${spec.assetId} has no character shape`);
@@ -4616,7 +5535,7 @@ var PixelLabProvider = class _PixelLabProvider {
         }
       }
       if (endFrame) {
-        const start = startFrame ?? (character.parentFile && existsSync2(character.parentFile) ? imageMetadata(readFileSync(character.parentFile)) : null);
+        const start = startFrame ?? (character.parentFile && existsSync3(character.parentFile) ? imageMetadata(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`
@@ -4774,7 +5693,7 @@ var PixelLabProvider = class _PixelLabProvider {
         }
       }
       if (endFrame) {
-        const start = startFrame ?? (object.parentFile && existsSync2(object.parentFile) ? imageMetadata(readFileSync(object.parentFile)) : null);
+        const start = startFrame ?? (object.parentFile && existsSync3(object.parentFile) ? imageMetadata(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`
@@ -5084,7 +6003,7 @@ 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 = path2.join(dir, `${jobId}-${index}.png`);
+      const file = path3.join(dir, `${jobId}-${index}.png`);
       writeFileSync(file, Buffer.from(image.base64, "base64"));
       return { url: `file://${file}`, ...role ? { role } : {} };
     });
@@ -5290,7 +6209,7 @@ var PixelLabProvider = class _PixelLabProvider {
         seed: spec.seed
       });
       const jobId = randomUUID();
-      writeFileSync(path2.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), png);
+      writeFileSync(path3.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), png);
       return { jobId };
     }
     if (spec.generator === "tiles") {
@@ -5319,17 +6238,46 @@ var PixelLabProvider = class _PixelLabProvider {
       });
       return { jobId: res2.tile_id, metadata: { backgroundJobId: res2.background_job_id } };
     }
+    if (spec.generator === "terrain" && spec.terrainOrientation === "sidescroller") {
+      const baseTileIds = await this.terrainBaseTileIds(context?.terrainLinks);
+      const res2 = await this.client.createTilesetSidescroller({
+        lowerDescription: spec.terrainLowerDescription,
+        transitionDescription: spec.terrainTransitionDescription,
+        lowerBaseTileId: baseTileIds.lower,
+        tileSize: spec.terrainTileSize,
+        transitionSize: spec.terrainTransitionSize,
+        outline: spec.outline,
+        shading: spec.shading,
+        detail: spec.detail,
+        seed: spec.seed
+      });
+      return {
+        jobId: res2.tileset_id,
+        metadata: {
+          backgroundJobId: res2.background_job_id,
+          ...Object.keys(baseTileIds).length ? { baseTileIds } : {}
+        }
+      };
+    }
     if (spec.generator === "terrain") {
+      const baseTileIds = await this.terrainBaseTileIds(context?.terrainLinks);
       const res2 = await this.client.createTileset({
         lowerDescription: spec.terrainLowerDescription,
         upperDescription: spec.terrainUpperDescription,
         transitionDescription: spec.terrainTransitionDescription,
+        lowerBaseTileId: baseTileIds.lower,
+        upperBaseTileId: baseTileIds.upper,
         tileSize: spec.terrainTileSize,
         mode: spec.terrainMode,
         shapeStyle: spec.terrainShapeStyle,
         spreadX: spec.terrainSpreadX,
         slopeSize: spec.terrainSlopeSize,
         raggedness: spec.terrainRaggedness,
+        roundness: spec.terrainRoundness,
+        boundaryAmplitude: spec.terrainBoundaryAmplitude,
+        boundarySeed: spec.terrainBoundarySeed,
+        stepSlope: spec.terrainStepSlope,
+        connectDiagonals: spec.terrainConnectDiagonals,
         transitionSize: spec.terrainTransitionSize,
         view: spec.terrainView,
         outline: spec.outline,
@@ -5337,7 +6285,13 @@ var PixelLabProvider = class _PixelLabProvider {
         detail: spec.detail,
         seed: spec.seed
       });
-      return { jobId: res2.tileset_id, metadata: { backgroundJobId: res2.background_job_id } };
+      return {
+        jobId: res2.tileset_id,
+        metadata: {
+          backgroundJobId: res2.background_job_id,
+          ...Object.keys(baseTileIds).length ? { baseTileIds } : {}
+        }
+      };
     }
     if (spec.generator === "isometricTile") {
       const res2 = await this.client.createIsometricTile({
@@ -5359,7 +6313,8 @@ var PixelLabProvider = class _PixelLabProvider {
         width: spec.width,
         height: spec.height,
         noBackground: spec.noBackground,
-        seed: spec.seed
+        seed: spec.seed,
+        targetPalette: { colors: spec.palette, name: spec.paletteName, maxColors: spec.maxColors }
       });
       return { jobId: res2.background_job_id };
     }
@@ -5502,6 +6457,14 @@ var PixelLabProvider = class _PixelLabProvider {
       });
       return this.cacheCleanupResult([res2.png], res2.usage, roles, revision.sourceFps);
     }
+    if (revision.mode === "normal-map") {
+      const strip = roles ? { base64: joinStripPng(images.map((member) => Buffer.from(member.base64, "base64"))).toString("base64"), format: "png" } : image;
+      const res2 = await this.client.normalMap({ image: strip, frames: roles?.length ?? 1, convention: revision.convention });
+      return {
+        jobId: res2.background_job_id,
+        metadata: roles ? { revisionMembers: roles, ...revision.sourceFps != null ? { revisionFps: revision.sourceFps } : {} } : {}
+      };
+    }
     if (revision.mode === "interpolate") {
       const lastFrame = this.readLastFrame(spec);
       if (!lastFrame) throw new Error(`${spec.styleId}/${spec.assetId}: interpolate needs lastFrame, the ending keyframe`);
@@ -5619,11 +6582,11 @@ var PixelLabProvider = class _PixelLabProvider {
   cacheCleanupResult(pngs, usage, roles, fps) {
     const jobId = randomUUID();
     if (!roles) {
-      writeFileSync(path2.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), pngs[0]);
+      writeFileSync(path3.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), pngs[0]);
       return { jobId, metadata: { revisionUsage: usage } };
     }
     for (const [index, png] of pngs.entries()) {
-      writeFileSync(path2.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`), png);
+      writeFileSync(path3.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`), png);
     }
     return { jobId, metadata: { revisionUsage: usage, revisionMembers: roles, ...fps != null ? { revisionFps: fps } : {} } };
   }
@@ -5647,6 +6610,7 @@ var PixelLabProvider = class _PixelLabProvider {
     if (revisionMode === "reduce-colors" || revisionMode === "correct-pixelart" || revisionMode === "remove-background") {
       return this.pollCachedRevision(jobId, context);
     }
+    if (revisionMode === "normal-map") return this.pollNormalMap(jobId, context);
     if (revisionMode === "animate" || revisionMode === "animate-pixminimax" || revisionMode === "animate-skeleton" || revisionMode === "interpolate" || revisionMode === "edit-animation") {
       return this.pollAnimateRevision(jobId, context);
     }
@@ -5654,8 +6618,8 @@ var PixelLabProvider = class _PixelLabProvider {
     if (generator === "vfx") return this.pollVfx(jobId, context);
     if (generator === "imageProFlash") return this.pollRevision(jobId);
     if (generator === "pixflux") {
-      const file = path2.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
-      if (existsSync2(file)) {
+      const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+      if (existsSync3(file)) {
         const sourceUrl = `file://${file}`;
         return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }] };
       }
@@ -5711,13 +6675,14 @@ var PixelLabProvider = class _PixelLabProvider {
    */
   async submitVfx(spec, context) {
     const vfx = spec.vfx;
+    if (vfx.description) return this.submitVfxArtist(spec, context);
     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 (!existsSync2(file)) throw new Error(`vfx sprite does not exist yet: ${file}`);
+      if (!existsSync3(file)) throw new Error(`vfx sprite does not exist yet: ${file}`);
       const bytes = readFileSync(file);
       if (sha256(bytes) !== vfx.sprite.sha256) {
         throw new Error(`vfx sprite changed after the manifest was resolved: ${file}; run the command again`);
@@ -5765,50 +6730,137 @@ var PixelLabProvider = class _PixelLabProvider {
       // 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);
+    await this.cacheVfxFrames(jobId, exported, workbenchVfxUrls(exported));
     return { jobId, metadata: { vfx: { ...facts(exported, name), recipe } } };
   }
+  /**
+   * Ask PixelLab's VFX artist (`POST /vfx`) for a `vfx` description: a
+   * plain background job, polled by `pollVfxArtist`. Every submission is a
+   * new effect. The manifest's description is the whole effect, not a change
+   * to an earlier one, so it is never sent with `effect_id`; the effect this
+   * asset made last time stays in My effects and its id is recorded here.
+   */
+  async submitVfxArtist(spec, context) {
+    const vfx = spec.vfx;
+    let sprite;
+    if (vfx.sprite && "reference" in vfx.sprite) {
+      throw new Error("PixelLab's VFX artist takes a sprite's pixels, not a PixelLab reference; point vfx.sprite at a PNG file");
+    } else if (vfx.sprite) {
+      const { file } = vfx.sprite;
+      if (!existsSync3(file)) throw new Error(`vfx sprite does not exist yet: ${file}`);
+      const bytes = readFileSync(file);
+      if (sha256(bytes) !== vfx.sprite.sha256) {
+        throw new Error(`vfx sprite changed after the manifest was resolved: ${file}; run the command again`);
+      }
+      sprite = vfxArtistSprite(bytes, `vfx sprite ${file}`).image;
+    }
+    const previous = context?.replacedMetadata?.vfx ?? context?.lastGenerationMetadata?.vfx;
+    const artist = vfx.artist ?? "lite";
+    const submitted = await this.client.createVfx({ description: vfx.description, artist, sprite, name: vfx.name });
+    return {
+      jobId: submitted.background_job_id,
+      metadata: {
+        vfx: {
+          artist,
+          quotedGenerations: submitted.quoted_generations ?? null,
+          ...typeof previous?.effectId === "string" ? { previousEffect: previous.effectId } : {}
+        }
+      }
+    };
+  }
   /** 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);
+  async cacheVfxFrames(jobId, facts, urls, atlas) {
+    const sheet = await this.client.download(urls.sheet);
+    const frameAtlas = atlas ?? (urls.atlas ? JSON.parse((await this.client.download(urls.atlas)).toString("utf8")) : void 0);
+    const frames = sliceVfxSheet(sheet, facts, frameAtlas);
     const dir = _PixelLabProvider.cacheDir("vfx");
-    frames.forEach((frame, index) => writeFileSync(path2.join(dir, `${jobId}-${index}.png`), frame));
+    frames.forEach((frame, index) => writeFileSync(path3.join(dir, `${jobId}-${index}.png`), frame));
     writeFileSync(
-      path2.join(dir, `${jobId}.json`),
-      JSON.stringify({ effectId: exported.effectId, count: frames.length, fps: exported.fps, loop: exported.loop })
+      path3.join(dir, `${jobId}.json`),
+      JSON.stringify({ effectId: facts.effectId, count: frames.length, fps: facts.fps, loop: facts.loop })
     );
   }
   async pollVfx(jobId, context) {
     const dir = _PixelLabProvider.cacheDir("vfx");
-    const sidecar = path2.join(dir, `${jobId}.json`);
+    const sidecar = path3.join(dir, `${jobId}.json`);
     const cached = () => {
-      if (!existsSync2(sidecar)) return null;
+      if (!existsSync3(sidecar)) return null;
       const facts2 = JSON.parse(readFileSync(sidecar, "utf8"));
-      const files2 = Array.from({ length: facts2.count }, (_, index) => path2.join(dir, `${jobId}-${index}.png`));
-      return files2.every((file) => existsSync2(file)) ? { facts: facts2, files: files2 } : null;
+      const files2 = Array.from({ length: facts2.count }, (_, index) => path3.join(dir, `${jobId}-${index}.png`));
+      return files2.every((file) => existsSync3(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);
+    let artistDone;
+    if (!found && recorded?.artist) {
+      if (recorded.fileUrls?.sheet && recorded.effectId) {
+        await this.cacheVfxFrames(jobId, recorded, {
+          sheet: recorded.fileUrls.sheet,
+          atlas: recorded.fileUrls.atlas
+        });
+      } else {
+        const job = await this.client.getBackgroundJob(jobId);
+        if (job.status === "failed") return { status: "failed", error: `vfx job failed upstream${vfxJobFailure(job.last_response)}` };
+        if (job.status !== "completed") return { status: "processing" };
+        try {
+          artistDone = await this.cacheVfxArtistResult(jobId, job.last_response ?? {}, recorded);
+        } catch (error) {
+          return { status: "failed", error: error instanceof Error ? error.message : String(error) };
+        }
+        artistDone.billed = billedFromUsage(job.usage);
+      }
+      found = cached();
+    } else if (!found && recorded?.downloadBase && Array.isArray(recorded.files)) {
+      const exported = recorded;
+      await this.cacheVfxFrames(jobId, exported, workbenchVfxUrls(exported));
       found = cached();
     }
     if (!found) {
-      return { status: "failed", error: "vfx frames are no longer cached locally; re-run submit for this asset (free)" };
+      return {
+        status: "failed",
+        error: recorded?.artist ? "vfx frames are no longer cached locally and their download links were not recorded; re-run submit for this asset (paid)" : "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")}` }));
+    const metadata = {
+      ...files.length > 1 ? { frameSet: { fps: facts.fps, count: files.length, loop: facts.loop } } : {},
+      ...artistDone ? { vfx: artistDone.vfx } : {}
+    };
     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 } } } : {},
+      ...Object.keys(metadata).length ? { metadata } : {},
+      billed: artistDone?.billed ?? null
+    };
+  }
+  /**
+   * A delivered VFX artist job: cut its sheet into the cache and return the
+   * effect's facts, merged over what submit recorded (poll replaces the
+   * whole `vfx` key). Download links are kept only when they carry no
+   * credential, so a committed lockfile never holds a signed URL.
+   */
+  async cacheVfxArtistResult(jobId, done, recorded) {
+    const result = parseVfxArtistResult(done, jobId);
+    const atlas = result.atlas ? JSON.parse((await this.client.download(result.atlas.url)).toString("utf8")) : void 0;
+    const size = vfxArtistFrameFacts(result, atlas);
+    const facts = { effectId: result.effectId, ...size, fps: result.fps ?? 12, loop: result.loop ?? false };
+    await this.cacheVfxFrames(jobId, facts, { sheet: result.sheet.url }, atlas);
+    const urls = [result.sheet.url, ...result.atlas ? [result.atlas.url] : []];
+    return {
+      vfx: {
+        ...recorded,
+        ...facts,
+        editUrl: result.editUrl,
+        name: result.name,
+        message: result.message,
+        anchor: result.anchor,
+        parts: result.parts,
+        files: result.files.map((file) => file.name),
+        ...urls.every(shouldPersistSourceUrl) ? { fileUrls: { sheet: result.sheet.url, ...result.atlas ? { atlas: result.atlas.url } : {} } } : {}
+      },
       billed: null
     };
   }
@@ -5821,10 +6873,10 @@ var PixelLabProvider = class _PixelLabProvider {
     };
     if (Array.isArray(roles) && roles.length) {
       const sources = roles.map((role, index) => ({
-        url: `file://${path2.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`)}`,
+        url: `file://${path3.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`)}`,
         role: String(role)
       }));
-      if (sources.some((source) => !existsSync2(source.url.slice("file://".length)))) return gone;
+      if (sources.some((source) => !existsSync3(source.url.slice("file://".length)))) return gone;
       const fps = context?.metadata?.revisionFps;
       const frames = sources.every((source) => source.role.startsWith("frame-"));
       return {
@@ -5836,11 +6888,58 @@ var PixelLabProvider = class _PixelLabProvider {
         billed: billedFromUsage(usage)
       };
     }
-    const file = path2.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
-    if (!existsSync2(file)) return gone;
+    const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+    if (!existsSync3(file)) return gone;
     const sourceUrl = `file://${file}`;
     return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }], billed: billedFromUsage(usage) };
   }
+  /**
+   * A `normal-map` revision: a background job whose map is
+   * `last_response.image`. A loop's map comes back as the strip it was sent
+   * as, and is cut into one file per frame under the parent's roles. Nothing
+   * downstream palette-snaps it: the manifest refuses a normal map in a
+   * style with `enforcePalette` or `quality`.
+   */
+  async pollNormalMap(jobId, context) {
+    const job = await this.client.getBackgroundJob(jobId);
+    if (job.status === "failed") return { status: "failed", error: "normal-map job failed upstream" };
+    if (job.status !== "completed") return { status: "processing" };
+    const billed = billedFromUsage(job.usage);
+    const png = normalMapResultPng(job.last_response);
+    if (!png) {
+      return {
+        status: "failed",
+        error: `Invalid PixelLab response for normal-map job ${jobId}: completed with no image at last_response.image (got: ${Object.keys(job.last_response ?? {}).join(", ") || "no keys"})`
+      };
+    }
+    const roles = context?.metadata?.revisionMembers;
+    if (Array.isArray(roles) && roles.length) {
+      let frames;
+      try {
+        frames = splitStripPng(png, roles.length);
+      } catch (error) {
+        return { status: "failed", error: `normal-map job ${jobId}: ${error.message}` };
+      }
+      const sources = frames.map((frame, index) => {
+        const file2 = path3.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+        writeFileSync(file2, frame);
+        return { url: `file://${file2}`, role: String(roles[index]) };
+      });
+      const fps = context?.metadata?.revisionFps;
+      return {
+        status: "ready",
+        objectId: jobId,
+        sourceUrl: sources[0].url,
+        sources,
+        ...typeof fps === "number" ? { metadata: { frameSet: { fps, count: sources.length } } } : {},
+        billed
+      };
+    }
+    const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+    writeFileSync(file, png);
+    const sourceUrl = `file://${file}`;
+    return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }], billed };
+  }
   /**
    * `animate`/`animate-pixminimax` revisions: a plain background job, like
    * `pollRevision` above, but completing with an ORDERED FRAME LIST instead
@@ -5893,7 +6992,7 @@ var PixelLabProvider = class _PixelLabProvider {
         }
         const base64 = extractBase64(item);
         if (base64) {
-          const file = path2.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+          const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
           writeFileSync(file, Buffer.from(base64, "base64"));
           urls.push(`file://${file}`);
           continue;
@@ -5944,7 +7043,7 @@ var PixelLabProvider = class _PixelLabProvider {
       const candidate = done[key];
       const base64 = extractBase64(candidate);
       if (base64) {
-        const file = path2.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+        const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
         writeFileSync(file, Buffer.from(base64, "base64"));
         const sourceUrl = `file://${file}`;
         return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }], billed };
@@ -5953,7 +7052,7 @@ var PixelLabProvider = class _PixelLabProvider {
     if (Array.isArray(done.images) && done.images.length) {
       const base64 = extractBase64(done.images[0]);
       if (base64) {
-        const file = path2.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+        const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
         writeFileSync(file, Buffer.from(base64, "base64"));
         const sourceUrl = `file://${file}`;
         return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }], billed };
@@ -5987,7 +7086,7 @@ var PixelLabProvider = class _PixelLabProvider {
       for (const [index, candidate] of done.images.entries()) {
         const base64 = extractBase64(candidate);
         if (!base64) continue;
-        const file = path2.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+        const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
         writeFileSync(file, Buffer.from(base64, "base64"));
         urls.push(`file://${file}`);
       }
@@ -6017,7 +7116,7 @@ var PixelLabProvider = class _PixelLabProvider {
     for (const [index, candidate] of images.entries()) {
       const base64 = extractBase64(candidate);
       if (!base64) continue;
-      const file = path2.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+      const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
       writeFileSync(file, Buffer.from(base64, "base64"));
       urls.push(`file://${file}`);
     }
@@ -6096,6 +7195,26 @@ var PixelLabProvider = class _PixelLabProvider {
       throw err;
     }
   }
+  /**
+   * The base tile id of each terrain a connected set shares: the other
+   * set's recorded `terrainIds`, or, for a set downloaded before pixelkiln
+   * recorded them, read from PixelLab's own record of it (a free GET).
+   */
+  async terrainBaseTileIds(links) {
+    const ids = {};
+    for (const side of ["lower", "upper"]) {
+      const link = links?.[side];
+      if (!link) continue;
+      const id = link.terrainId ?? (await this.client.getTileset(link.objectId)).metadata.terrainIds[link.terrain];
+      if (!id) {
+        throw new Error(
+          `PixelLab terrain: tileset ${link.objectId} has no ${link.terrain} terrain id to connect this set's ${side} terrain to`
+        );
+      }
+      ids[side] = id;
+    }
+    return ids;
+  }
   /**
    * `/create-tileset` reports progress the same way `tiles` does (423 while
    * drawing, 200 once finished), but each tile's image comes back embedded
@@ -6107,7 +7226,8 @@ var PixelLabProvider = class _PixelLabProvider {
    */
   async pollTerrain(tilesetId, context) {
     try {
-      const { tileset, usage } = await this.client.getTileset(tilesetId);
+      const { tileset, usage, metadata } = await this.client.getTileset(tilesetId);
+      const sidescroller = metadata.view === "side" || context?.spec?.terrainOrientation === "sidescroller";
       const backgroundJobId = context?.metadata?.backgroundJobId;
       const billed = billedFromUsage(usage) ?? await this.billedForJob(backgroundJobId);
       const sources = [];
@@ -6115,7 +7235,7 @@ 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 = path2.join(_PixelLabProvider.cacheDir(), `${tilesetId}-${index}.png`);
+        const file = path3.join(_PixelLabProvider.cacheDir(), `${tilesetId}-${index}.png`);
         writeFileSync(file, Buffer.from(tile.image.base64, "base64"));
         sources.push({ url: `file://${file}`, role });
         terrainTiles.push({ role, corners: tile.corners, pattern4x4: tile.pattern_4x4 });
@@ -6125,7 +7245,13 @@ var PixelLabProvider = class _PixelLabProvider {
         objectId: tilesetId,
         sourceUrl: sources[0]?.url ?? null,
         sources,
-        metadata: { terrainTypes: tileset.terrain_types, terrainTiles },
+        metadata: {
+          terrainTypes: sidescroller ? ["lower", "upper"] : tileset.terrain_types,
+          ...sidescroller ? { providerTerrainTypes: tileset.terrain_types, view: "side" } : {},
+          terrainTiles,
+          // Each terrain's base tile id, which a connected set sends.
+          ...Object.keys(metadata.terrainIds).length ? { terrainIds: metadata.terrainIds } : {}
+        },
         billed
       };
     } catch (err) {
@@ -6145,7 +7271,7 @@ 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 = path2.join(_PixelLabProvider.cacheDir(), `${tileId}.png`);
+      const file = path3.join(_PixelLabProvider.cacheDir(), `${tileId}.png`);
       writeFileSync(file, Buffer.from(image.base64, "base64"));
       return {
         status: "ready",
@@ -6189,8 +7315,8 @@ var PixelLabProvider = class _PixelLabProvider {
       return { objectId: `${jobId}#${index}`, sourceUrl: url };
     }
     if (generator === "imagePro" || generator === "uiElement") {
-      const file = path2.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
-      if (!existsSync2(file)) throw new Error(`${generator} job ${jobId} has no cached candidate at index ${index}`);
+      const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+      if (!existsSync3(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);
@@ -6781,7 +7907,7 @@ function retroError(value) {
 import { createHash as createHash2 } from "crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import os2 from "os";
-import path3 from "path";
+import path4 from "path";
 var DEFAULT_BASE_URL2 = "https://api.cloud.scenario.com/v1";
 var SOURCE_PROTOCOL2 = "scenario:";
 var SUBMIT_RETRIES = 8;
@@ -7164,7 +8290,7 @@ var ScenarioProvider = class _ScenarioProvider {
   }
 };
 function uploadCachePath() {
-  return process.env.SCENARIO_UPLOAD_CACHE ?? path3.join(os2.tmpdir(), "pixelkiln-scenario", "uploads.json");
+  return process.env.SCENARIO_UPLOAD_CACHE ?? path4.join(os2.tmpdir(), "pixelkiln-scenario", "uploads.json");
 }
 function uploadCacheKey(baseUrl, projectId, digest2) {
   return createHash2("sha256").update(`${baseUrl}
@@ -7182,7 +8308,7 @@ function readUploadCache() {
 function writeUploadCache(key, assetId) {
   try {
     const file = uploadCachePath();
-    mkdirSync2(path3.dirname(file), { recursive: true });
+    mkdirSync2(path4.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
     writeFileSync2(tmp, JSON.stringify({ ...readUploadCache(), [key]: assetId }));
     renameSync(tmp, file);
@@ -7382,8 +8508,8 @@ function redactScenarioError(value, secrets) {
 
 // src/providers/comfyui.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile2 } from "fs/promises";
-import path4 from "path";
+import { readFile as readFile3 } from "fs/promises";
+import path5 from "path";
 var DEFAULT_BASE_URL3 = "http://127.0.0.1:8188";
 var BUILTIN_BINDINGS = /* @__PURE__ */ new Set([
   "prompt",
@@ -7520,10 +8646,10 @@ var ComfyUIProvider = class _ComfyUIProvider {
   }
   async resolveOptions(value, context) {
     const options = parseOptions(value);
-    const workflowPath = path4.resolve(context.root, options.workflowFile);
+    const workflowPath = path5.resolve(context.root, options.workflowFile);
     let raw;
     try {
-      raw = await readFile2(workflowPath, "utf8");
+      raw = await readFile3(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)}`
@@ -7575,10 +8701,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 = path4.resolve(context.root, item);
+          const file = path5.resolve(context.root, item);
           let bytes;
           try {
-            bytes = await readFile2(file);
+            bytes = await readFile3(file);
           } catch (error) {
             throw new Error(
               `ComfyUI ${label} could not be read at ${file}: ${error instanceof Error ? error.message : String(error)}`
@@ -7713,6 +8839,11 @@ var ComfyUIProvider = class _ComfyUIProvider {
           "ComfyUI has no binding for numColors/paletteImage/dithering \u2014 those are PixelLab's /reduce-colors parameters. A reduce-colors revision on ComfyUI is whatever your own workflow does with bindings.sourceImage; write that behavior into the graph directly."
         );
       }
+      if (spec.revision.convention) {
+        throw new Error(
+          "ComfyUI has no binding for convention \u2014 that is PixelLab's /normal-map parameter. A normal-map revision on ComfyUI is whatever your own workflow does; build the green-channel convention into the graph."
+        );
+      }
       if ((!options.bindings.width || !options.bindings.height) && spec.revision.sourceWidth != null && spec.revision.sourceHeight != null && (spec.width !== spec.revision.sourceWidth || spec.height !== spec.revision.sourceHeight)) {
         throw new Error(
           "ComfyUI revisions without width/height bindings must keep the source dimensions"
@@ -7735,7 +8866,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
         setBinding(workflow2, binding, input);
         return;
       }
-      const bytes = await readFile2(input.path);
+      const bytes = await readFile3(input.path);
       if (sha256(bytes) !== input.sha256) {
         throw new Error(`ComfyUI provider input "${name}" changed before upload`);
       }
@@ -7802,7 +8933,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
       if (!spec.revision.sourceSha256 || !spec.revision.sourceFormat) {
         throw new Error("ComfyUI revision source is not ready");
       }
-      const sourceBytes = await readFile2(spec.revision.sourceFile);
+      const sourceBytes = await readFile3(spec.revision.sourceFile);
       if (sha256(sourceBytes) !== spec.revision.sourceSha256) {
         throw new Error("ComfyUI revision source changed before upload");
       }
@@ -7816,7 +8947,7 @@ var ComfyUIProvider = class _ComfyUIProvider {
         if (!spec.revision.maskSha256 || !spec.revision.maskFormat) {
           throw new Error("ComfyUI revision mask is not ready");
         }
-        const maskBytes = await readFile2(spec.revision.maskFile);
+        const maskBytes = await readFile3(spec.revision.maskFile);
         if (sha256(maskBytes) !== spec.revision.maskSha256) {
           throw new Error("ComfyUI revision mask changed before upload");
         }
@@ -8536,9 +9667,9 @@ registerProvider({
 });
 
 // src/manifest.ts
-import { readFile as readFile4 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import path7 from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import path8 from "path";
 
 // src/loop-directions.ts
 var SINGLE_OUTPUT_FIELDS = ["file", "cell", "remoteId", "source", "sourceByStyle", "outputRole"];
@@ -8626,17 +9757,17 @@ function isObject2(value) {
 }
 
 // src/outputs.ts
-import { existsSync as existsSync4 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync5 } from "fs";
+import path7 from "path";
 
 // src/lock.ts
-import { readFile as readFile3, writeFile as writeFile2, rename, mkdir as mkdir2, rmdir, rm, stat } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import path5 from "path";
+import { readFile as readFile4, writeFile as writeFile3, rename, mkdir as mkdir3, rmdir, rm, stat } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import path6 from "path";
 async function loadLock(lockPath) {
-  if (!existsSync3(lockPath)) return { version: 2, entries: {} };
+  if (!existsSync4(lockPath)) return { version: 2, entries: {} };
   try {
-    return parseLock(JSON.parse(await readFile3(lockPath, "utf8")));
+    return parseLock(JSON.parse(await readFile4(lockPath, "utf8")));
   } catch (err) {
     throw new ProjectError(
       `Lockfile at ${lockPath} is malformed:
@@ -8649,7 +9780,7 @@ var saveQueues = /* @__PURE__ */ new Map();
 var dirtyPatches = /* @__PURE__ */ new WeakMap();
 var dirtyDeletes = /* @__PURE__ */ new WeakMap();
 function saveLock(lockPath, lock) {
-  const queueKey = path5.resolve(lockPath);
+  const queueKey = path6.resolve(lockPath);
   const previous = saveQueues.get(queueKey) ?? Promise.resolve();
   const next = previous.catch(() => {
   }).then(() => writeLockNow(lockPath, lock));
@@ -8661,7 +9792,7 @@ function saveLock(lockPath, lock) {
   return next;
 }
 async function writeLockNow(lockPath, lock) {
-  await mkdir2(path5.dirname(path5.resolve(lockPath)), { recursive: true });
+  await mkdir3(path6.dirname(path6.resolve(lockPath)), { recursive: true });
   const release = await acquireFileLock(lockPath);
   try {
     await writeLockWhileHeld(lockPath, lock);
@@ -8671,9 +9802,9 @@ async function writeLockNow(lockPath, lock) {
 }
 async function writeLockWhileHeld(file, lock) {
   let disk = { version: 2, entries: {} };
-  if (existsSync3(file)) {
+  if (existsSync4(file)) {
     try {
-      disk = parseLock(JSON.parse(await readFile3(file, "utf8")));
+      disk = parseLock(JSON.parse(await readFile4(file, "utf8")));
     } catch (err) {
       throw new ProjectError(
         `Refusing to overwrite malformed lockfile at ${file}: ${err instanceof Error ? err.message : String(err)}`,
@@ -8702,7 +9833,7 @@ async function writeLockWhileHeld(file, lock) {
   }
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile2(tmp, JSON.stringify({ version: 2, entries: sorted }, null, 2) + "\n");
+    await writeFile3(tmp, JSON.stringify({ version: 2, entries: sorted }, null, 2) + "\n");
     await rename(tmp, file);
   } finally {
     await rm(tmp, { force: true });
@@ -8768,7 +9899,7 @@ async function acquireFileLock(file) {
   const deadline = Date.now() + FILE_LOCK_TIMEOUT_MS;
   for (; ; ) {
     try {
-      await mkdir2(lockDir);
+      await mkdir3(lockDir);
       return async () => {
         await rmdir(lockDir).catch(() => {
         });
@@ -8806,22 +9937,22 @@ function totalSpend(lock, unit = "generations") {
 
 // src/outputs.ts
 function portableOutputPath(file, manifestDir) {
-  const root = path6.resolve(manifestDir);
-  const absolute = path6.isAbsolute(file) ? path6.normalize(file) : path6.resolve(root, file);
-  const relative = path6.relative(root, absolute);
-  const value = path6.isAbsolute(relative) ? absolute : relative;
-  return value.split(path6.sep).join("/");
+  const root = path7.resolve(manifestDir);
+  const absolute = path7.isAbsolute(file) ? path7.normalize(file) : path7.resolve(root, file);
+  const relative = path7.relative(root, absolute);
+  const value = path7.isAbsolute(relative) ? absolute : relative;
+  return value.split(path7.sep).join("/");
 }
 function resolveOutputPath(recordedPath, manifestDir) {
-  if (path6.isAbsolute(recordedPath)) return path6.normalize(recordedPath);
-  if (path6.win32.isAbsolute(recordedPath)) return recordedPath;
-  return path6.resolve(manifestDir, recordedPath.split(/[\\/]/).join(path6.sep));
+  if (path7.isAbsolute(recordedPath)) return path7.normalize(recordedPath);
+  if (path7.win32.isAbsolute(recordedPath)) return recordedPath;
+  return path7.resolve(manifestDir, recordedPath.split(/[\\/]/).join(path7.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 = path6.extname(file);
+  const originalExt = path7.extname(file);
   const ext = mediaType ? mediaExtension(mediaType) : originalExt || ".png";
   const stem = originalExt ? file.slice(0, -originalExt.length) : file;
   if (total === 1) return `${stem}${ext}`;
@@ -8835,10 +9966,10 @@ function isFrameSetEntry(entry) {
   return entry.generator === "frames" && isMemberSetEntry(entry);
 }
 function sourceIsStem(source, entry, manifestDir) {
-  return isMemberSetEntry(entry) && !existsSync4(path6.resolve(manifestDir, source));
+  return isMemberSetEntry(entry) && !existsSync5(path7.resolve(manifestDir, source));
 }
 function sourceOutputPath(source, entry, index, manifestDir) {
-  const absolute = path6.resolve(manifestDir, source);
+  const absolute = path7.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);
@@ -8925,7 +10056,7 @@ function resolveSpecOutputs(spec, lock, manifestDir) {
     id: spec.assetId,
     index: 0,
     path: spec.outFile,
-    absolutePath: path6.resolve(spec.outFile),
+    absolutePath: path7.resolve(spec.outFile),
     sha256: ""
   }];
 }
@@ -8946,9 +10077,9 @@ function frameSetLoop(entry) {
 
 // src/manifest.ts
 async function loadManifest(manifestPath) {
-  const abs = path7.resolve(manifestPath);
-  if (!existsSync5(abs)) throw new ProjectError(`No manifest at ${abs}`);
-  const expansion = expandLoopDirections(JSON.parse(await readFile4(abs, "utf8")));
+  const abs = path8.resolve(manifestPath);
+  if (!existsSync6(abs)) throw new ProjectError(`No manifest at ${abs}`);
+  const expansion = expandLoopDirections(JSON.parse(await readFile5(abs, "utf8")));
   if (expansion.issues.length) {
     throw new ProjectError(`Manifest at ${abs} is invalid:
 ${expansion.issues.map((i) => `  ${i}`).join("\n")}`);
@@ -9045,12 +10176,38 @@ ${issues}`);
     visited.add(assetId);
   };
   for (const assetId of Object.keys(parsed.data.assets)) visitParents(assetId, []);
+  const connectVisiting = [];
+  const connectVisited = /* @__PURE__ */ new Set();
+  const visitConnections = (assetId) => {
+    if (connectVisited.has(assetId)) return;
+    const cycleStart = connectVisiting.indexOf(assetId);
+    if (cycleStart >= 0) {
+      unknownReferences.push(
+        `assets.${assetId}.connect: connection cycle ${[...connectVisiting.slice(cycleStart), assetId].join(" -> ")}`
+      );
+      return;
+    }
+    connectVisiting.push(assetId);
+    for (const [side, link] of Object.entries(parsed.data.assets[assetId]?.connect ?? {})) {
+      if (!link) continue;
+      if (!parsed.data.assets[link.of]) {
+        unknownReferences.push(`assets.${assetId}.connect.${side}.of: unknown asset "${link.of}"`);
+      } else if (link.of === assetId) {
+        unknownReferences.push(`assets.${assetId}.connect.${side}.of: a set cannot connect to itself`);
+      } else {
+        visitConnections(link.of);
+      }
+    }
+    connectVisiting.pop();
+    connectVisited.add(assetId);
+  };
+  for (const assetId of Object.keys(parsed.data.assets)) visitConnections(assetId);
   if (unknownReferences.length) {
     throw new ProjectError(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
   const loopFamilies = Object.keys(expansion.families).length ? { loopFamilies: expansion.families } : {};
-  return { manifest: parsed.data, root: path7.dirname(abs), path: abs, ...loopFamilies };
+  return { manifest: parsed.data, root: path8.dirname(abs), path: abs, ...loopFamilies };
 }
 function assetInStyle(asset, styleId, style) {
   if (asset.styles.length) return asset.styles.includes(styleId);
@@ -9059,6 +10216,13 @@ function assetInStyle(asset, styleId, style) {
 function parentAssetId(asset) {
   return asset?.revision?.from ?? asset?.state?.of ?? asset?.animation?.of ?? asset?.portrait?.of ?? asset?.outfit?.of;
 }
+function dependencyAssetIds(asset) {
+  const parent = parentAssetId(asset);
+  return [
+    ...parent ? [parent] : [],
+    ...[asset?.connect?.lower?.of, asset?.connect?.upper?.of].filter((id) => Boolean(id))
+  ];
+}
 function formatManifestIssues(issues) {
   return issues.flatMap((issue) => {
     if (issue.code === "invalid_union") {
@@ -9146,11 +10310,12 @@ async function resolveSpecs(loaded, filter) {
   }
   const requestedAssetIds = new Set(assetFilter.length ? assetFilter : Object.keys(manifest.assets));
   const resolutionAssetIds = new Set(requestedAssetIds);
-  for (const assetId of [...requestedAssetIds]) {
-    let current = parentAssetId(manifest.assets[assetId]);
-    while (current && !resolutionAssetIds.has(current)) {
-      resolutionAssetIds.add(current);
-      current = parentAssetId(manifest.assets[current]);
+  const pending = [...requestedAssetIds];
+  while (pending.length) {
+    for (const dependency of dependencyAssetIds(manifest.assets[pending.pop()])) {
+      if (resolutionAssetIds.has(dependency) || !manifest.assets[dependency]) continue;
+      resolutionAssetIds.add(dependency);
+      pending.push(dependency);
     }
   }
   const styleDependencies = /* @__PURE__ */ new Map();
@@ -9188,11 +10353,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 = path7.resolve(root, rel);
+    const abs = path8.resolve(root, rel);
     let hit = styleImageCache.get(abs);
     if (!hit) {
-      if (!existsSync5(abs)) throw new Error(`${what} not found: ${abs}`);
-      const buf = await readFile4(abs);
+      if (!existsSync6(abs)) throw new Error(`${what} not found: ${abs}`);
+      const buf = await readFile5(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) {
@@ -9218,7 +10383,7 @@ async function resolveSpecs(loaded, filter) {
       styleImageDimensions.push(loadedImage);
     }
     const resolvedImages = style.styleImages.map((image) => {
-      const hit = styleImageCache.get(path7.resolve(root, image.path));
+      const hit = styleImageCache.get(path8.resolve(root, image.path));
       return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
     });
     const styleSpecs = /* @__PURE__ */ new Map();
@@ -9305,6 +10470,9 @@ async function resolveSpecs(loaded, filter) {
           `assets.${assetId}: ${asset.portrait ? "portrait" : "outfit"} needs a character style; "${styleId}" generates ${generator}`
         );
       }
+      if (asset.connect && generator !== "terrain") {
+        throw new Error(`assets.${assetId}: connect needs a terrain style; "${styleId}" generates ${generator}`);
+      }
       if ((asset.pieces || asset.elements) && generator !== "uiAsset") {
         throw new Error(
           `assets.${assetId}: ${asset.pieces ? "pieces" : "elements"} needs a uiAsset style; "${styleId}" generates ${generator}`
@@ -9316,7 +10484,18 @@ async function resolveSpecs(loaded, filter) {
       let terrainUpperDescription;
       let terrainTransitionDescription;
       let prompt;
-      if (generator === "terrain") {
+      if (generator === "terrain" && style.terrainOrientation === "sidescroller") {
+        const parsed = parseTerrainDescriptions(subject);
+        if (!parsed || parsed.transition) {
+          throw new Error(
+            `assets.${assetId}: a sidescroller terrain needs exactly "1). <platform body> 2). <top layer>" in its prompt (e.g. 1). stone brick texture 2). green grass texture)`
+          );
+        }
+        const wrap = (text) => [style.promptPrefix, text, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
+        terrainLowerDescription = wrap(parsed.lower);
+        terrainTransitionDescription = wrap(parsed.upper);
+        prompt = subject.trim();
+      } else if (generator === "terrain") {
         const parsed = parseTerrainDescriptions(subject);
         if (!parsed) {
           throw new Error(
@@ -9333,12 +10512,12 @@ async function resolveSpecs(loaded, filter) {
       } else {
         prompt = [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
       }
-      const relFile = asset.file ?? path7.join(asset.category ?? "", `${assetId}.png`);
-      const outFile = path7.resolve(root, style.outDir, relFile);
-      const qualityOutFile = style.quality ? path7.resolve(root, style.quality.outDir, pngPath(relFile)) : void 0;
+      const relFile = asset.file ?? path8.join(asset.category ?? "", `${assetId}.png`);
+      const outFile = path8.resolve(root, style.outDir, relFile);
+      const qualityOutFile = style.quality ? path8.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;
+      const terrainTiles = generator === "terrain" ? terrainTileCount(style.terrainTransitionSize, style.terrainMode, style.terrainOrientation) : 0;
       const base = {
         styleId,
         assetId,
@@ -9361,6 +10540,8 @@ async function resolveSpecs(loaded, filter) {
         uiColorPalette: generator === "uiAsset" || generator === "uiElement" ? style.uiColorPalette : void 0,
         ...generator === "imageProFlash" && style.styleTraits ? { styleTraits: style.styleTraits } : {},
         palette: style.palette,
+        ...generator === "imagePro" && style.paletteName ? { paletteName: style.paletteName } : {},
+        ...generator === "imagePro" && style.maxColors != null ? { maxColors: style.maxColors } : {},
         enforcePalette: style.enforcePalette,
         noBackground: style.noBackground,
         tileSize: generator === "tiles" ? tileSize : void 0,
@@ -9395,8 +10576,14 @@ async function resolveSpecs(loaded, filter) {
         terrainSpreadX: generator === "terrain" ? style.terrainSpreadX : void 0,
         terrainSlopeSize: generator === "terrain" ? style.terrainSlopeSize : void 0,
         terrainRaggedness: generator === "terrain" ? style.terrainRaggedness : void 0,
+        terrainRoundness: generator === "terrain" ? style.terrainRoundness : void 0,
+        terrainBoundaryAmplitude: generator === "terrain" ? style.terrainBoundaryAmplitude : void 0,
+        terrainBoundarySeed: generator === "terrain" ? style.terrainBoundarySeed : void 0,
+        terrainStepSlope: generator === "terrain" ? style.terrainStepSlope : void 0,
+        terrainConnectDiagonals: generator === "terrain" ? style.terrainConnectDiagonals : void 0,
         terrainTransitionSize: generator === "terrain" ? style.terrainTransitionSize : void 0,
         terrainView: generator === "terrain" ? style.terrainView : void 0,
+        terrainOrientation: generator === "terrain" ? style.terrainOrientation : void 0,
         isometricTileSize: generator === "isometricTile" ? style.isometricTileSize : void 0,
         isometricTileShape: generator === "isometricTile" ? style.isometricTileShape : void 0,
         // A revision in a character or objectPro style is a provider edit of
@@ -9407,7 +10594,7 @@ async function resolveSpecs(loaded, filter) {
         // 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),
+        cost: generator === "tiles" ? tilesCost(tileSize, tileVariations) : generator === "terrain" ? terrainCost(style.terrainMode, size, style.terrainOrientation) : generator === "isometricTile" ? isometricTileCost() : generationCost(width, height, generator),
         costUnit: "generations",
         candidates: generator === "tiles" ? tileVariations : generator === "terrain" ? terrainTiles : generator === "1dir" || generator === "imagePro" ? candidateCount(size) : 1
       };
@@ -9431,7 +10618,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: path7.resolve(root, style.quality.fixerPython) } : {},
+            ...style.quality.fixerPython ? { fixerPython: path8.resolve(root, style.quality.fixerPython) } : {},
             ...style.quality.fps == null ? {} : { fps: style.quality.fps }
           }
         } : {},
@@ -9468,6 +10655,11 @@ async function resolveSpecs(loaded, filter) {
         if (sourceSpec.generator === "tiles" || sourceSpec.generator === "terrain") {
           throw new Error(`assets.${assetId}: a tile set cannot be mirrored; its edges carry meaning`);
         }
+        if (sourceSpec.revision?.mode === "normal-map") {
+          throw new Error(
+            `assets.${assetId}: a normal map cannot be mirrored by flipping its pixels; every red channel would still point the old way. Make a normal-map revision of the mirrored art instead`
+          );
+        }
         if (sourceSpec.character?.kind === "animation") {
           const facing = sourceSpec.character.animation.direction;
           const mirrored = MIRRORED_DIRECTION[facing];
@@ -9514,7 +10706,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: existsSync5(file) ? await sha256File(file) : null }
+          styleAnchor: { assetId: anchorId, spec: anchorSpec, file, sha256: existsSync6(file) ? await sha256File(file) : null }
         };
       }
       const characterParent = asset.state?.of ?? asset.animation?.of ?? asset.portrait?.of;
@@ -9527,7 +10719,7 @@ async function resolveSpecs(loaded, filter) {
           parentAssetId: characterParent,
           parentSpec,
           parentFile,
-          parentSha256: existsSync5(parentFile) ? await sha256File(parentFile) : null,
+          parentSha256: existsSync6(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
@@ -9545,7 +10737,7 @@ async function resolveSpecs(loaded, filter) {
           parentAssetId: characterParent,
           parentSpec,
           parentFile,
-          parentSha256: existsSync5(parentFile) ? await sha256File(parentFile) : null,
+          parentSha256: existsSync6(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
         };
@@ -9567,7 +10759,7 @@ async function resolveSpecs(loaded, filter) {
           animation: sourceSpec.character.animation,
           outfit: {
             reference: {
-              path: path7.resolve(root, asset.outfit.reference),
+              path: path8.resolve(root, asset.outfit.reference),
               sha256: referenceImage.hash,
               width: referenceImage.width,
               height: referenceImage.height,
@@ -9588,25 +10780,30 @@ async function resolveSpecs(loaded, filter) {
             `Provider "${activeProvider.id}" does not support ${asset.revision.mode} revisions`
           );
         }
+        if (asset.revision.mode === "normal-map" && (style.enforcePalette || style.quality)) {
+          throw new Error(
+            `assets.${assetId}: a normal-map revision is lighting data, not art, and style "${styleId}" sets ${style.enforcePalette ? "enforcePalette" : "quality"}, which would recolour it. Put it in a style without enforcePalette or quality, and name the parent's style with revision.fromStyle`
+          );
+        }
         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 ? path7.resolve(root, sourceSpec.source) : sourceSpec.outFile);
+        const sourceStem = sourceSpec.quality?.outFile ?? (sourceSpec.source ? path8.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 ? path7.resolve(root, asset.revision.mask) : void 0;
+        const maskFile = asset.revision.mask ? path8.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 ? path7.resolve(root, asset.revision.paletteImage) : void 0;
+        const paletteImageFile = asset.revision.paletteImage ? path8.resolve(root, asset.revision.paletteImage) : void 0;
         const paletteImage = paletteImageFile ? await optionalRevisionImage(paletteImageFile, "revision palette image", "png") : null;
-        const lastFrameFile = asset.revision.lastFrame ? path7.resolve(root, asset.revision.lastFrame) : void 0;
+        const lastFrameFile = asset.revision.lastFrame ? path8.resolve(root, asset.revision.lastFrame) : void 0;
         const lastFrame = lastFrameFile ? await optionalRevisionImage(lastFrameFile, "revision last frame") : null;
-        const keypointsFile = asset.revision.keypointsFile ? path7.resolve(root, asset.revision.keypointsFile) : void 0;
+        const keypointsFile = asset.revision.keypointsFile ? path8.resolve(root, asset.revision.keypointsFile) : void 0;
         const keypoints = keypointsFile ? await optionalSkeletonSet(keypointsFile) : null;
         resolved.revision = {
           mode: asset.revision.mode,
@@ -9662,6 +10859,7 @@ async function resolveSpecs(loaded, filter) {
           ...asset.revision.skeletonTemplate ? { skeletonTemplate: asset.revision.skeletonTemplate } : {},
           ...asset.revision.description ? { description: asset.revision.description } : {},
           ...asset.revision.removalTask ? { removalTask: asset.revision.removalTask } : {},
+          ...asset.revision.convention ? { convention: asset.revision.convention } : {},
           ...asset.revision.driftThreshold == null ? {} : { driftThreshold: asset.revision.driftThreshold },
           ...asset.revision.subjectDescription ? { subjectDescription: asset.revision.subjectDescription } : {},
           ...asset.revision.initialPose ? { initialPose: asset.revision.initialPose } : {},
@@ -9718,6 +10916,24 @@ async function resolveSpecs(loaded, filter) {
           };
         }
       }
+      if (asset.connect) {
+        const links = {};
+        for (const side of ["lower", "upper"]) {
+          const link = asset.connect[side];
+          if (!link) continue;
+          if (!styleSpecs.has(link.of)) {
+            throw new Error(
+              `assets.${assetId}.connect.${side}.of: "${link.of}" is not in style "${styleId}"; connected terrain sets share one style`
+            );
+          }
+          const linkedSpec = await finalize(link.of);
+          if (linkedSpec.generator !== "terrain") {
+            throw new Error(`assets.${assetId}.connect.${side}.of: "${link.of}" is not a terrain set`);
+          }
+          links[side] = { assetId: link.of, terrain: link.terrain, spec: linkedSpec };
+        }
+        resolved.terrainConnect = links;
+      }
       if (asset.scene) resolved.scene = await resolveMapScene(root, styleId, assetId, resolved.generator, asset.scene, activeProvider);
       resolved.specHash = specHash(
         resolved,
@@ -9776,7 +10992,7 @@ async function resolveSpecs(loaded, filter) {
   return specs;
 }
 function pngPath(file) {
-  const extension = path7.extname(file);
+  const extension = path8.extname(file);
   return extension ? `${file.slice(0, -extension.length)}.png` : `${file}.png`;
 }
 async function resolveMapScene(root, styleId, assetId, generator, scene, provider) {
@@ -9786,12 +11002,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 = path7.resolve(root, scene.image);
+  const file = path8.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 = path7.resolve(root, placement.mask);
+    const maskFile = path8.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(
@@ -9809,20 +11025,20 @@ async function resolveVfxShape(root, assetId, vfx, defaultName) {
   let recipe;
   let recordedSprite;
   if (vfx.recipe) {
-    const file = path7.resolve(root, vfx.recipe);
-    if (!existsSync5(file)) throw new Error(`assets.${assetId}.vfx.recipe: VFX recipe not found: ${file}`);
+    const file = path8.resolve(root, vfx.recipe);
+    if (!existsSync6(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 : path7.resolve(root, vfx.sprite) : recordedSprite;
+  const spriteRef = vfx.sprite ? isVfxReference(vfx.sprite) ? vfx.sprite : path8.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`);
+    const image = await optionalRevisionImage(spriteRef, `assets.${assetId}.vfx.sprite`, vfx.description ? "png" : void 0);
     sprite = { file: spriteRef, sha256: image?.hash ?? null, width: image?.width ?? null, height: image?.height ?? null, format: image?.format ?? null };
   }
   return {
@@ -9831,12 +11047,14 @@ async function resolveVfxShape(root, assetId, vfx, defaultName) {
     ...vfx.parts?.length ? { parts: vfx.parts } : {},
     ...sprite ? { sprite } : {},
     ...vfx.fps !== void 0 ? { fps: vfx.fps } : {},
-    name: vfx.name ?? defaultName
+    // The artist caps a name at 80 characters; a long default is cut, not refused.
+    name: vfx.name ?? (vfx.description ? defaultName.slice(0, 80) : defaultName),
+    ...vfx.description ? { description: vfx.description, artist: vfx.artist ?? "lite" } : {}
   };
 }
 async function optionalRevisionImage(file, label, requiredFormat) {
-  if (!existsSync5(file)) return null;
-  const bytes = await readFile4(file);
+  if (!existsSync6(file)) return null;
+  const bytes = await readFile5(file);
   const metadata = imageMetadata(bytes);
   if (!metadata) throw new Error(`${label} is not a readable PNG or JPEG: ${file}`);
   if (requiredFormat && metadata.format !== requiredFormat) {
@@ -9845,8 +11063,8 @@ async function optionalRevisionImage(file, label, requiredFormat) {
   return { hash: sha256(bytes), ...metadata };
 }
 async function optionalSkeletonSet(file) {
-  if (!existsSync5(file)) return null;
-  const bytes = await readFile4(file);
+  if (!existsSync6(file)) return null;
+  const bytes = await readFile5(file);
   let json;
   try {
     json = JSON.parse(bytes.toString("utf8"));
@@ -9856,17 +11074,17 @@ async function optionalSkeletonSet(file) {
   return { hash: sha256(bytes), skeleton: parseSkeletonSet(json, file) };
 }
 async function revisionSourceMembers(stem, label) {
-  if (existsSync5(stem)) return null;
+  if (existsSync6(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) => existsSync5(at(direction)))) {
+    if (set.every((direction) => existsSync6(at(direction)))) {
       roles = [...set];
       break;
     }
   }
   if (!roles.length) {
-    for (let index = 0; existsSync5(at(`frame-${String(index).padStart(2, "0")}`)); index++) {
+    for (let index = 0; existsSync6(at(`frame-${String(index).padStart(2, "0")}`)); index++) {
       roles.push(`frame-${String(index).padStart(2, "0")}`);
     }
   }
@@ -9892,8 +11110,8 @@ async function resolveStyleImages(loaded, styleId) {
   if (!style) throw new Error(`Unknown style "${styleId}"`);
   const out = [];
   for (const img of style.styleImages) {
-    const file = path7.resolve(loaded.root, img.path);
-    const buf = await readFile4(file);
+    const file = path8.resolve(loaded.root, img.path);
+    const buf = await readFile5(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) {
@@ -9923,7 +11141,7 @@ async function resolveCharacterShape(asset, style, kind, files) {
   };
   if (asset.concept) {
     const image = await files.load(asset.concept, "Concept image");
-    shape.concept = { path: path7.resolve(files.root, asset.concept), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+    shape.concept = { path: path8.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;
@@ -9931,7 +11149,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: path7.resolve(files.root, rel),
+        path: path8.resolve(files.root, rel),
         sha256: image.hash,
         width: image.width,
         height: image.height,
@@ -9952,7 +11170,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: path7.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      return { path: path8.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     };
     shape.animation = {
       mode: animationMode,
@@ -9983,7 +11201,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: path7.resolve(files.root, south), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      shape.reference = { path: path8.resolve(files.root, south), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     }
   }
   if (asset.state) {
@@ -10011,7 +11229,7 @@ async function resolveObjectProShape(assetId, asset, style, kind, files) {
     }
     const pose = async (rel, what) => {
       const image = await files.load(rel, what);
-      return { path: path7.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
+      return { path: path8.resolve(files.root, rel), sha256: image.hash, width: image.width, height: image.height, format: image.format };
     };
     shape.animation = {
       mode: asset.animation.mode ?? "v3",
@@ -10031,11 +11249,11 @@ function characterDirections(directions) {
 }
 
 // src/project.ts
-import path15 from "path";
+import path16 from "path";
 
 // src/env.ts
-import { readFileSync as readFileSync3, existsSync as existsSync6 } from "fs";
-import path8 from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync7 } from "fs";
+import path9 from "path";
 function loadEnvFiles(dir) {
   const loaded = [];
   for (const [file, vars] of envFiles(dir)) {
@@ -10049,8 +11267,8 @@ function loadEnvFiles(dir) {
 function envFiles(dir) {
   const out = [];
   for (const name of [".env.local", ".env"]) {
-    const file = path8.join(dir, name);
-    if (!existsSync6(file)) continue;
+    const file = path9.join(dir, name);
+    if (!existsSync7(file)) continue;
     try {
       out.push([file, parseEnv(readFileSync3(file, "utf8"))]);
     } catch {
@@ -10078,12 +11296,12 @@ function parseEnv(contents) {
 }
 
 // src/pipeline/plan.ts
-import { existsSync as existsSync9 } from "fs";
-import path14 from "path";
+import { existsSync as existsSync10 } from "fs";
+import path15 from "path";
 
 // src/pipeline/mirror.ts
-import { mkdir as mkdir3, readFile as readFile5, rename as rename2, writeFile as writeFile3 } from "fs/promises";
-import path9 from "path";
+import { mkdir as mkdir4, readFile as readFile6, rename as rename2, writeFile as writeFile4 } from "fs/promises";
+import path10 from "path";
 
 // src/palette.ts
 function normalizePalette(values) {
@@ -10220,11 +11438,11 @@ async function deriveMirror(spec, lock, lockPath, opts = {}) {
   const outputs = [];
   const written = [];
   for (const [index, member] of members.entries()) {
-    const bytes = flipHorizontal(await readFile5(member.file));
+    const bytes = flipHorizontal(await readFile6(member.file));
     const target = expectedOutputPath(spec, member.role, index, members.length, MediaType.PNG);
-    await mkdir3(path9.dirname(target), { recursive: true });
+    await mkdir4(path10.dirname(target), { recursive: true });
     const tmp = `${target}.pixelkiln.tmp`;
-    await writeFile3(tmp, bytes);
+    await writeFile4(tmp, bytes);
     await rename2(tmp, target);
     written.push(target);
     outputs.push({
@@ -10284,20 +11502,20 @@ async function deriveMirror(spec, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/quality-profile.ts
-import { existsSync as existsSync7 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync8 } from "fs";
+import path13 from "path";
 
 // src/pipeline/refine.ts
-import path11 from "path";
+import path12 from "path";
 import { execFile } from "child_process";
-import { mkdtemp, readFile as readFile7, rm as rm3 } from "fs/promises";
+import { mkdtemp, readFile as readFile8, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
 import { promisify } from "util";
 
 // src/artifacts.ts
-import path10 from "path";
+import path11 from "path";
 import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir4, readFile as readFile6, rename as rename3, rm as rm2, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile7, rename as rename3, rm as rm2, writeFile as writeFile5 } from "fs/promises";
 var activeTransactions = /* @__PURE__ */ new Set();
 function message(error) {
   return error instanceof Error ? error.message : String(error);
@@ -10306,7 +11524,7 @@ function digest(data) {
   return createHash4("sha256").update(data).digest("hex");
 }
 function portableRelative(from, to) {
-  return path10.relative(from, path10.resolve(to)).split(path10.sep).join("/") || ".";
+  return path11.relative(from, path11.resolve(to)).split(path11.sep).join("/") || ".";
 }
 function canonical2(value) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
@@ -10356,12 +11574,12 @@ function parseArtifactManifest(absolute, data) {
   return raw;
 }
 async function readArtifactBundleManifest(manifestPath) {
-  const absolute = path10.resolve(manifestPath);
-  return parseArtifactManifest(absolute, await readFile6(absolute, "utf8"));
+  const absolute = path11.resolve(manifestPath);
+  return parseArtifactManifest(absolute, await readFile7(absolute, "utf8"));
 }
 async function readOptional(file) {
   try {
-    return await readFile6(file);
+    return await readFile7(file);
   } catch (error) {
     if (isCode(error, "ENOENT")) return null;
     throw error;
@@ -10380,8 +11598,8 @@ function processIsAlive(pid) {
   }
 }
 function validTemporaryPath(candidate, destination, type) {
-  return path10.dirname(candidate) === path10.dirname(destination) && path10.basename(candidate).startsWith(
-    `.${path10.basename(destination)}.pixelkiln-${type}-`
+  return path11.dirname(candidate) === path11.dirname(destination) && path11.basename(candidate).startsWith(
+    `.${path11.basename(destination)}.pixelkiln-${type}-`
   );
 }
 function parseTransaction(journal, data) {
@@ -10401,7 +11619,7 @@ async function removeTransactionFiles(journal) {
   await rm2(transactionMarker(journal), { force: true });
 }
 async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
-  const journal = path10.resolve(recoveryFile);
+  const journal = path11.resolve(recoveryFile);
   const bytes = await readOptional(journal);
   if (!bytes) {
     await rm2(transactionMarker(journal), { force: true });
@@ -10417,7 +11635,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(path10.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(path11.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.`
       );
@@ -10463,7 +11681,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
   await removeTransactionFiles(journal);
 }
 function createArtifactBundleManifest(manifestPath, outputs, provenance) {
-  const root = path10.dirname(path10.resolve(manifestPath));
+  const root = path11.dirname(path11.resolve(manifestPath));
   const sources = provenance.sources.map((source) => ({
     ...source,
     path: portableRelative(root, source.path)
@@ -10493,11 +11711,11 @@ function withArtifactManifest(manifestPath, outputs, provenance) {
   ];
 }
 async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
-  const absoluteManifest = path10.resolve(manifestPath);
+  const absoluteManifest = path11.resolve(manifestPath);
   const recoveryFile = `${absoluteManifest}.transaction`;
   const allowedDestinations = /* @__PURE__ */ new Set([
     absoluteManifest,
-    ...outputs.map((output) => path10.resolve(output.path))
+    ...outputs.map((output) => path11.resolve(output.path))
   ]);
   await recoverArtifactTransaction(recoveryFile, allowedDestinations);
   const existingManifestBytes = await readOptional(absoluteManifest);
@@ -10515,13 +11733,13 @@ async function writeManagedArtifactBundle(manifestPath, outputs, provenance, opt
     }
   }
   if (!options.force) {
-    const root = path10.dirname(absoluteManifest);
+    const root = path11.dirname(absoluteManifest);
     const recorded = new Map(
-      previous?.outputs.map((output) => [path10.resolve(root, output.path), output.sha256]) ?? []
+      previous?.outputs.map((output) => [path11.resolve(root, output.path), output.sha256]) ?? []
     );
     const conflicts = [];
     for (const output of outputs) {
-      const destination = path10.resolve(output.path);
+      const destination = path11.resolve(output.path);
       const current = await readOptional(destination);
       if (!current || digest(current) === digest(output.data)) continue;
       const expected = recorded.get(destination);
@@ -10543,15 +11761,15 @@ Pass { force: true } (CLI: --force) to take ownership and replace the complete b
   );
 }
 async function verifyArtifactBundle(manifestPath) {
-  const absolute = path10.resolve(manifestPath);
+  const absolute = path11.resolve(manifestPath);
   const raw = await readArtifactBundleManifest(absolute);
-  const root = path10.dirname(absolute);
+  const root = path11.dirname(absolute);
   const changedSources = [];
   const changedOutputs = [];
   for (const source of raw.sources) {
     let actual = null;
     try {
-      actual = digest(await readFile6(path10.resolve(root, source.path)));
+      actual = digest(await readFile7(path11.resolve(root, source.path)));
     } catch (error) {
       if (!isCode(error, "ENOENT")) throw error;
     }
@@ -10559,7 +11777,7 @@ async function verifyArtifactBundle(manifestPath) {
   }
   for (const output of raw.outputs) {
     try {
-      if (digest(await readFile6(path10.resolve(root, output.path))) !== output.sha256) {
+      if (digest(await readFile7(path11.resolve(root, output.path))) !== output.sha256) {
         changedOutputs.push(output.path);
       }
     } catch (error) {
@@ -10615,7 +11833,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: path10.resolve(file.path), data: Buffer.from(file.data) };
+    return { destination: path11.resolve(file.path), data: Buffer.from(file.data) };
   });
   const destinations = /* @__PURE__ */ new Set();
   for (const artifact of normalized) {
@@ -10631,7 +11849,7 @@ async function writeArtifactBundle(files, options = {}) {
   const unchanged = [];
   for (const artifact of normalized) {
     try {
-      const current = await readFile6(artifact.destination);
+      const current = await readFile7(artifact.destination);
       if (current.equals(artifact.data)) {
         unchanged.push(artifact.destination);
       } else {
@@ -10645,21 +11863,21 @@ async function writeArtifactBundle(files, options = {}) {
   if (!changed.length) return { changed: [], unchanged };
   const token = randomUUID3();
   for (const [index, artifact] of changed.entries()) {
-    const basename = path10.basename(artifact.destination);
-    artifact.stage = path10.join(
-      path10.dirname(artifact.destination),
+    const basename = path11.basename(artifact.destination);
+    artifact.stage = path11.join(
+      path11.dirname(artifact.destination),
       `.${basename}.pixelkiln-stage-${token}-${index}`
     );
     if (artifact.existed) {
-      artifact.backup = path10.join(
-        path10.dirname(artifact.destination),
+      artifact.backup = path11.join(
+        path11.dirname(artifact.destination),
         `.${basename}.pixelkiln-backup-${token}-${index}`
       );
     }
   }
-  const journal = options.recoveryFile ? path10.resolve(options.recoveryFile) : null;
+  const journal = options.recoveryFile ? path11.resolve(options.recoveryFile) : null;
   if (journal) {
-    await mkdir4(path10.dirname(journal), { recursive: true });
+    await mkdir5(path11.dirname(journal), { recursive: true });
     const transaction = {
       format: "pixelkiln-artifact-transaction",
       version: 1,
@@ -10673,7 +11891,7 @@ async function writeArtifactBundle(files, options = {}) {
       }))
     };
     try {
-      await writeFile4(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
+      await writeFile5(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
       activeTransactions.add(journal);
     } catch (error) {
       throw new Error(
@@ -10684,9 +11902,9 @@ async function writeArtifactBundle(files, options = {}) {
   }
   try {
     for (const [index, artifact] of changed.entries()) {
-      await mkdir4(path10.dirname(artifact.destination), { recursive: true });
+      await mkdir5(path11.dirname(artifact.destination), { recursive: true });
       await options.beforeStage?.(artifact.destination, index);
-      await writeFile4(artifact.stage, artifact.data, { flag: "wx" });
+      await writeFile5(artifact.stage, artifact.data, { flag: "wx" });
     }
   } catch (error) {
     const cleanupErrors2 = await rollback(changed);
@@ -10709,7 +11927,7 @@ async function writeArtifactBundle(files, options = {}) {
       artifact.promoted = true;
     }
     if (journal) {
-      await writeFile4(transactionMarker(journal), `${token}
+      await writeFile5(transactionMarker(journal), `${token}
 `, { flag: "wx" });
       durableCommit = true;
       await options.afterCommit?.();
@@ -10950,16 +12168,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 = path11.resolve(options.source);
-  const output = path11.resolve(options.output);
+  const source = path12.resolve(options.source);
+  const output = path12.resolve(options.output);
   if (source === output) throw new Error("Refinement source and output must be different files.");
-  const record = path11.resolve(qualityRecordPath(output));
+  const record = path12.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 readFile7(source));
+    sourcePng = decodePng(await readFile8(source));
   } catch (error) {
     throw new Error(`Cannot read refinement source ${source}: ${message2(error)}`, { cause: error });
   }
@@ -10976,8 +12194,8 @@ async function refineAsset(options) {
       );
     }
   }
-  const temp = await mkdtemp(path11.join(tmpdir(), "pixelkiln-refine-"));
-  const recovered = path11.join(temp, "native.png");
+  const temp = await mkdtemp(path12.join(tmpdir(), "pixelkiln-refine-"));
+  const recovered = path12.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 {
@@ -10998,7 +12216,7 @@ async function refineAsset(options) {
       );
     }
     const detection = parseDetection(firstJsonObject(stdout));
-    const native = decodePng(await readFile7(recovered));
+    const native = decodePng(await readFile8(recovered));
     const quantized = quantizeToPalette(native, palette);
     const png = encodeRgbaPng(quantized.width, quantized.height, quantized.pixels);
     const audit = auditRefinement(
@@ -11062,18 +12280,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 = path11.resolve(options.output);
-  const record = path11.resolve(qualityRecordPath(output));
+  const output = path12.resolve(options.output);
+  const record = path12.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) => path11.resolve(source.path)));
+  const sourceSet = new Set(options.sources.map((source) => path12.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 mkdtemp(path11.join(tmpdir(), "pixelkiln-refine-frames-"));
+  const temp = await mkdtemp(path12.join(tmpdir(), "pixelkiln-refine-frames-"));
   try {
     const frames = [];
     const outputs = [];
@@ -11081,8 +12299,8 @@ async function refineFrameSet(options) {
     const sourcePaths = [];
     let firstOptions = null;
     for (const [index, sourceEntry] of options.sources.entries()) {
-      const source = path11.resolve(sourceEntry.path);
-      const temporaryOutput = path11.join(temp, `${String(index).padStart(2, "0")}.png`);
+      const source = path12.resolve(sourceEntry.path);
+      const temporaryOutput = path12.join(temp, `${String(index).padStart(2, "0")}.png`);
       const refined = await refineAsset({
         source,
         output: temporaryOutput,
@@ -11114,7 +12332,7 @@ async function refineFrameSet(options) {
       });
       outputs.push({
         path: finalOutputs[index],
-        data: await readFile7(temporaryOutput)
+        data: await readFile8(temporaryOutput)
       });
     }
     const first = frames[0];
@@ -11157,7 +12375,7 @@ async function refineFrameSet(options) {
     );
     return {
       sources: sourcePaths,
-      outputs: outputs.map((item) => path11.resolve(item.path)),
+      outputs: outputs.map((item) => path12.resolve(item.path)),
       record,
       frames,
       palette,
@@ -11168,12 +12386,12 @@ async function refineFrameSet(options) {
   }
 }
 async function checkQualityRecord(recordPath) {
-  const record = path11.resolve(recordPath);
+  const record = path12.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
-  const sources = manifest.sources.map((source2) => path11.resolve(path11.dirname(record), source2.path));
-  const outputs = manifest.outputs.map((output2) => path11.resolve(path11.dirname(record), output2.path));
+  const sources = manifest.sources.map((source2) => path12.resolve(path12.dirname(record), source2.path));
+  const outputs = manifest.outputs.map((output2) => path12.resolve(path12.dirname(record), output2.path));
   const source = sources[0] ?? "";
   const output = outputs[0] ?? "";
   const expectedCount = options.frameSet?.count ?? 1;
@@ -11206,7 +12424,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 = path11.resolve(recordPath);
+  const record = path12.resolve(recordPath);
   const manifest = await readArtifactBundleManifest(record);
   const options = parseRecordOptions(manifest, record);
   const verification = await verifyArtifactBundle(record);
@@ -11227,14 +12445,14 @@ async function approveQualityRecord(recordPath, approval) {
       `A refinement record must contain exactly ${expectedCount} source(s) and output(s).`
     );
   }
-  const root = path11.dirname(record);
+  const root = path12.dirname(record);
   const outputs = await Promise.all(manifest.outputs.map(async (entry) => {
-    const outputPath = path11.resolve(root, entry.path);
-    return { path: outputPath, data: await readFile7(outputPath) };
+    const outputPath = path12.resolve(root, entry.path);
+    return { path: outputPath, data: await readFile8(outputPath) };
   }));
   const sources = manifest.sources.map((source) => ({
     ...source,
-    path: path11.resolve(root, source.path)
+    path: path12.resolve(root, source.path)
   }));
   const approved = {
     ...options,
@@ -11266,8 +12484,8 @@ async function qualitySource(spec, lock) {
     if (spec.generator === "frames") {
       return { items: null, reason: "frame-set quality requires ordered downloaded provider outputs" };
     }
-    const source = path12.resolve(spec.root, spec.source);
-    return existsSync7(source) ? { items: [{ role: "source", path: source }] } : { items: null, reason: `declared source is missing: ${spec.source}` };
+    const source = path13.resolve(spec.root, spec.source);
+    return existsSync8(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" };
@@ -11296,7 +12514,7 @@ async function qualitySource(spec, lock) {
     }
     if (role) roles.add(role);
     const source = currentEntryOutputPath(entry, spec, index);
-    if (!existsSync7(source)) return { items: null, reason: `raw provider output is missing: ${source}` };
+    if (!existsSync8(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" };
     }
@@ -11315,7 +12533,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 (!existsSync7(record)) {
+  if (!existsSync8(record)) {
     return {
       key,
       state: "needs-refinement",
@@ -11333,7 +12551,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) => path12.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => path12.resolve(item))) || JSON.stringify(check.outputs.map((item) => path12.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => path12.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) => path13.resolve(item))) !== JSON.stringify(sourcePaths.map((item) => path13.resolve(item))) || JSON.stringify(check.outputs.map((item) => path13.resolve(item))) !== JSON.stringify(expectedOutputs.map((item) => path13.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,
@@ -11496,8 +12714,8 @@ async function requireApprovedQualitySources(specs, lock, assetIds, outputRoles)
 }
 
 // src/pipeline/revision.ts
-import { existsSync as existsSync8 } from "fs";
-import path13 from "path";
+import { existsSync as existsSync9 } from "fs";
+import path14 from "path";
 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());
@@ -11506,6 +12724,7 @@ async function inspectRevisionReadiness(spec, lock) {
   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.terrainConnect) return inspectTerrainConnect(spec, lock, /* @__PURE__ */ new Set());
   if (!spec.revision) return null;
   return inspectRevision(spec, lock, /* @__PURE__ */ new Set());
 }
@@ -11514,7 +12733,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 || !existsSync8(anchor.file)) return { ready: false, reason: `${label} has no generated south-facing file yet` };
+  if (!anchor.sha256 || !existsSync9(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` };
   }
@@ -11523,19 +12742,31 @@ async function inspectStyleAnchor(spec, lock, seen) {
   }
   return { ready: true, reason: `${label} is current` };
 }
+async function inspectTerrainConnect(spec, lock, seen) {
+  for (const link of [spec.terrainConnect.lower, spec.terrainConnect.upper]) {
+    if (!link) continue;
+    const label = `connected set ${spec.styleId}/${link.assetId}`;
+    const dependency = await inspectParent(link.spec, lock, seen);
+    if (!dependency.ready) return { ready: false, reason: `${label} is not ready: ${dependency.reason}` };
+    if (!lock.entries[lockKey(link.spec.styleId, link.spec.assetId)]?.objectId) {
+      return { ready: false, reason: `${label} has no PixelLab tileset id recorded` };
+    }
+  }
+  return { ready: true, reason: "connected sets are current" };
+}
 async function inspectScene(spec) {
   const scene = spec.scene;
   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 || !existsSync8(file)) return { ready: false, reason: `${label} does not exist yet: ${file}` };
+    if (!sha2562 || !existsSync9(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 || !existsSync8(sprite.file)) return { ready: false, reason: `vfx sprite does not exist yet: ${sprite.file}` };
+  if (!sprite.sha256 || !existsSync9(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" };
 }
@@ -11551,7 +12782,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 (!existsSync8(outfit.reference.path)) {
+  if (!existsSync9(outfit.reference.path)) {
     return { ready: false, reason: `outfit reference is missing: ${outfit.reference.path}` };
   }
   if (await sha256File(outfit.reference.path) !== outfit.reference.sha256) {
@@ -11565,7 +12796,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 || !existsSync8(character.parentFile)) {
+  if (!character.parentSha256 || !character.parentFile || !existsSync9(character.parentFile)) {
     return { ready: false, reason: `${label} has no generated south-facing file yet` };
   }
   if (await sha256File(character.parentFile) !== character.parentSha256) {
@@ -11583,7 +12814,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 || !existsSync8(object.parentFile)) {
+  if (!object.parentSha256 || !object.parentFile || !existsSync9(object.parentFile)) {
     return { ready: false, reason: `${label} has no generated south-facing file yet` };
   }
   if (await sha256File(object.parentFile) !== object.parentSha256) {
@@ -11609,7 +12840,7 @@ async function inspectRevision(spec, lock, seen) {
     const members = await inspectSourceMembers(spec, lock);
     if (!members.ready) return members;
   } else {
-    if (!revision.sourceSha256 || !existsSync8(revision.sourceFile)) {
+    if (!revision.sourceSha256 || !existsSync9(revision.sourceFile)) {
       return { ready: false, reason: `revision source is missing: ${revision.sourceFile}` };
     }
     if (await sha256File(revision.sourceFile) !== revision.sourceSha256) {
@@ -11617,7 +12848,7 @@ async function inspectRevision(spec, lock, seen) {
     }
   }
   if (revision.maskFile) {
-    if (!revision.maskSha256 || !existsSync8(revision.maskFile)) {
+    if (!revision.maskSha256 || !existsSync9(revision.maskFile)) {
       return { ready: false, reason: `revision mask is missing: ${revision.maskFile}` };
     }
     if (await sha256File(revision.maskFile) !== revision.maskSha256) {
@@ -11625,7 +12856,7 @@ async function inspectRevision(spec, lock, seen) {
     }
   }
   if (revision.lastFrameFile) {
-    if (!revision.lastFrameSha256 || !existsSync8(revision.lastFrameFile)) {
+    if (!revision.lastFrameSha256 || !existsSync9(revision.lastFrameFile)) {
       return { ready: false, reason: `revision last frame is missing: ${revision.lastFrameFile}` };
     }
     if (await sha256File(revision.lastFrameFile) !== revision.lastFrameSha256) {
@@ -11638,7 +12869,7 @@ async function inspectSourceMembers(spec, lock) {
   const revision = spec.revision;
   const members = revision.sourceMembers;
   for (const member of members) {
-    if (!existsSync8(member.file)) return { ready: false, reason: `revision source member is missing: ${member.file}` };
+    if (!existsSync9(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}` };
     }
@@ -11647,8 +12878,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) => path13.resolve(currentEntryOutputPath(entry, parent, index))).sort();
-  const found = members.map((member) => path13.resolve(member.file)).sort();
+  const recorded = entry.outputs.map((_, index) => path14.resolve(currentEntryOutputPath(entry, parent, index))).sort();
+  const found = members.map((member) => path14.resolve(member.file)).sort();
   if (recorded.length !== found.length || recorded.some((file, index) => file !== found[index])) {
     return {
       ready: false,
@@ -11689,6 +12920,10 @@ async function inspectParent(spec, lock, seen) {
     const inputs = await inspectObjectProParent(spec, lock, nextSeen);
     if (!inputs.ready) return inputs;
   }
+  if (spec.terrainConnect) {
+    const inputs = await inspectTerrainConnect(spec, lock, nextSeen);
+    if (!inputs.ready) return inputs;
+  }
   if (spec.quality) {
     const quality = await inspectQualityProfile(spec, lock);
     return quality?.state === "approved" ? { ready: true, reason: "approved quality output is current" } : {
@@ -11697,8 +12932,8 @@ async function inspectParent(spec, lock, seen) {
     };
   }
   if (spec.source) {
-    const source = path13.resolve(spec.root, spec.source);
-    return existsSync8(source) ? { ready: true, reason: "declared source is present" } : { ready: false, reason: `declared source is missing: ${spec.source}` };
+    const source = path14.resolve(spec.root, spec.source);
+    return existsSync9(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" };
@@ -11712,7 +12947,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 (!existsSync8(file)) return { ready: false, reason: `parent output is missing: ${file}` };
+    if (!existsSync9(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}` };
     }
@@ -11734,9 +12969,21 @@ function dependencies(spec) {
     spec.revision?.sourceSpec,
     spec.character?.parentSpec,
     spec.character?.styleAnchor?.spec,
-    spec.objectPro?.parentSpec
+    spec.objectPro?.parentSpec,
+    spec.terrainConnect?.lower?.spec,
+    spec.terrainConnect?.upper?.spec
   ].filter((parent) => Boolean(parent));
 }
+function changedTerrainConnection(spec, entry, lock) {
+  for (const side of ["lower", "upper"]) {
+    const link = spec.terrainConnect?.[side];
+    if (!link) continue;
+    const other = lock.entries[lockKey(link.spec.styleId, link.spec.assetId)];
+    const recorded = entry.terrainConnect?.[side];
+    if (!recorded || recorded.sourceObjectId !== other?.objectId) return link.assetId;
+  }
+  return null;
+}
 function resumeCommandForStatus(status) {
   if (status === "pending" || status === "processing") return "poll";
   if (status === "review") return "pick";
@@ -11768,6 +13015,7 @@ async function buildPlan(specs, lock, opts = {}) {
     const entry = lock.entries[key];
     let state;
     let reason;
+    const changedConnection = entry ? changedTerrainConnection(spec, entry, lock) : null;
     const revision = await inspectRevisionReadiness(spec, lock);
     if (revision && !revision.ready) {
       state = "blocked";
@@ -11776,7 +13024,7 @@ async function buildPlan(specs, lock, opts = {}) {
       state = "missing";
       reason = "--force";
     } else if (!entry && spec.source && spec.generator !== "frames" && spec.generator !== "vfx") {
-      if (existsSync9(path14.resolve(spec.root, spec.source))) {
+      if (existsSync10(path15.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -11784,7 +13032,7 @@ async function buildPlan(specs, lock, opts = {}) {
         reason = `declared source is missing: ${spec.source}`;
       }
     } else if (!entry) {
-      if (existsSync9(spec.outFile)) {
+      if (existsSync10(spec.outFile)) {
         state = "untracked";
         reason = "file on disk, no provenance recorded";
       } else {
@@ -11797,12 +13045,15 @@ 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) => !existsSync9(currentEntryOutputPath(entry, spec, index)))) {
+    } else if (spec.mirror && entry.status === "downloaded" && entry.outputs.some((_output, index) => !existsSync10(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: [] })) {
       state = "stale";
       reason = `outfit source ${spec.character.parentAssetId} changed; re-clothe the loop again`;
+    } else if (changedConnection) {
+      state = "stale";
+      reason = `connected set ${changedConnection} was regenerated; draw this set from its new terrain`;
     } else if (entry.status === "download-failed") {
       state = "recoverable";
       const force = entry.error?.includes("pass --force") ? " --force" : "";
@@ -11825,9 +13076,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) => !existsSync9(currentEntryOutputPath(entry, spec, index)))) {
+    } else if (entry.outputs.length === 0 || entry.outputs.some((_output, index) => !existsSync10(currentEntryOutputPath(entry, spec, index)))) {
       state = "orphaned";
-      reason = entry.outputs.length === 0 ? "no recorded output files" : `missing on disk: ${entry.outputs.filter((_output, index) => !existsSync9(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) => !existsSync10(currentEntryOutputPath(entry, spec, index))).map((o) => o.role ?? "asset").join(", ")}`;
     } else if (await anyOutputModified(entry, spec)) {
       state = "orphaned";
       reason = "output modified since download";
@@ -11918,13 +13169,13 @@ function summarize(plan) {
 
 // src/project.ts
 async function openProject(manifestPath = "pixelkiln.manifest.json", opts = {}) {
-  const absolute = path15.resolve(manifestPath);
-  const root = path15.dirname(absolute);
+  const absolute = path16.resolve(manifestPath);
+  const root = path16.dirname(absolute);
   if (opts.env !== false) {
     loadEnvFiles(root);
-    if (path15.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
+    if (path16.resolve(process.cwd()) !== root) loadEnvFiles(process.cwd());
   }
-  const lockPath = path15.resolve(opts.lockPath ?? path15.join(root, "pixelkiln.lock.json"));
+  const lockPath = path16.resolve(opts.lockPath ?? path16.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);
@@ -11953,47 +13204,10 @@ async function openProject(manifestPath = "pixelkiln.manifest.json", opts = {})
   };
 }
 
-// src/source-url.ts
-var SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
-  "access_token",
-  "apikey",
-  "api_key",
-  "auth",
-  "authorization",
-  "awsaccesskeyid",
-  "googleaccessid",
-  "key",
-  "sig"
-]);
-function isSensitiveSourceUrl(value) {
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    return false;
-  }
-  if (parsed.username || parsed.password) return true;
-  for (const key of parsed.searchParams.keys()) {
-    const normalized = key.toLowerCase();
-    if (SENSITIVE_QUERY_KEYS.has(normalized) || normalized.includes("credential") || normalized.includes("signature") || normalized.includes("security-token") || normalized.includes("token")) return true;
-  }
-  return false;
-}
-function shouldPersistSourceUrl(value) {
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    return true;
-  }
-  if (parsed.protocol === "data:" || parsed.protocol === "file:") return false;
-  return !isSensitiveSourceUrl(value);
-}
-
 // src/recipes.ts
-import path16 from "path";
-import { existsSync as existsSync10 } from "fs";
-import { readdir, readFile as readFile8 } from "fs/promises";
+import path17 from "path";
+import { existsSync as existsSync11 } from "fs";
+import { readdir, readFile as readFile9 } from "fs/promises";
 import { fileURLToPath } from "url";
 import { z as z4 } from "zod";
 var SHA256_RE = /^[0-9a-f]{64}$/;
@@ -12002,7 +13216,7 @@ var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
 var PortablePathSchema = z4.string().min(1).refine((value) => {
-  if (value.includes("\\") || path16.posix.isAbsolute(value)) return false;
+  if (value.includes("\\") || path17.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
@@ -12178,10 +13392,10 @@ function message3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path16.resolve(recipePath);
+  const absolute = path17.resolve(recipePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile8(absolute, "utf8"));
+    raw = JSON.parse(await readFile9(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read recipe ${absolute}: ${message3(error)}`, { cause: error });
   }
@@ -12192,13 +13406,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: path16.dirname(absolute), bundled };
+  return { recipe: parsed.data, authored: raw, path: absolute, dir: path17.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
-  if (!existsSync10(root)) return [];
+  if (!existsSync11(root)) return [];
   const out = [];
   for (const entry of await readdir(root, { withFileTypes: true })) {
-    const resolved = path16.join(root, entry.name);
+    const resolved = path17.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -12209,7 +13423,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path16.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path17.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)
@@ -12232,9 +13446,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path16.resolve(target);
-  if (existsSync10(local)) {
-    const recipePath = path16.basename(local) === RECIPE_FILE ? local : path16.join(local, RECIPE_FILE);
+  const local = path17.resolve(target);
+  if (existsSync11(local)) {
+    const recipePath = path17.basename(local) === RECIPE_FILE ? local : path17.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -12248,8 +13462,8 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path16.resolve(root, ...file.path.split("/"));
-  if (!existsSync10(absolute)) {
+  const absolute = path17.resolve(root, ...file.path.split("/"));
+  if (!existsSync11(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
   const actualSha256 = await sha256File(absolute);
@@ -12264,7 +13478,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 ? path16.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path17.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -12298,7 +13512,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path16.relative(cwd, destination).split(path16.sep).join("/") || ".";
+  const portableDir = path17.relative(cwd, destination).split(path17.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -12310,25 +13524,25 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path16.resolve(options.cwd ?? process.cwd());
+  const cwd = path17.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 ? path16.resolve(cwd, options.out) : path16.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path17.resolve(cwd, options.out) : path17.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: path16.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path17.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path16.join(destination, ...file.path.split("/")),
-    data: await readFile8(file.source)
+    path: path17.join(destination, ...file.path.split("/")),
+    data: await readFile9(file.source)
   })));
   if (!options.force) {
     for (const file of files) {
-      if (!existsSync10(file.path)) continue;
-      const current = await readFile8(file.path);
+      if (!existsSync11(file.path)) continue;
+      const current = await readFile9(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.`,
@@ -12352,9 +13566,9 @@ async function installRecipe(target, options = {}) {
 }
 
 // src/pipeline/audit.ts
-import { readFile as readFile9 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import path17 from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import path18 from "path";
 function paletteDistance(asset, reference) {
   if (!asset.length || !reference.length) return 0;
   let total = 0;
@@ -12390,12 +13604,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 (!existsSync11(output.absolutePath)) {
+      if (!existsSync12(output.absolutePath)) {
         missing.push(output.id);
         continue;
       }
       try {
-        const png = decodePng(await readFile9(output.absolutePath));
+        const png = decodePng(await readFile10(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -12419,10 +13633,10 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = path17.resolve(loaded.root, img.path);
-    if (!existsSync11(abs)) continue;
+    const abs = path18.resolve(loaded.root, img.path);
+    if (!existsSync12(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await readFile9(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await readFile10(abs)), 12));
     } catch {
     }
   }
@@ -12497,144 +13711,6 @@ function hex(c) {
   return `#${[c.r, c.g, c.b].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
 }
 
-// src/pixellab-utils.ts
-import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
-import path18 from "path";
-var UNZOOM_MIN_SIDE = 256;
-var UNZOOM_MAX_AREA = 2048 * 2048;
-function defaultUnzoomOut(input) {
-  const ext = path18.extname(input);
-  return `${ext ? input.slice(0, -ext.length) : input}.unzoomed.png`;
-}
-async function unzoomFile(client2, input, opts = {}) {
-  const out = path18.resolve(opts.out ?? defaultUnzoomOut(input));
-  if (path18.resolve(input) === out) throw new Error("unzoom will not overwrite its own input; pass a different --out");
-  if (existsSync12(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
-  const bytes = await readFile10(input);
-  const metadata = imageMetadata(bytes);
-  if (!metadata) throw new Error(`${input} is not a readable PNG or JPEG`);
-  const { width, height, format } = metadata;
-  if (width < UNZOOM_MIN_SIDE || height < UNZOOM_MIN_SIDE) {
-    throw new Error(
-      `${input} is ${width}x${height}; PixelLab's unzoom needs at least ${UNZOOM_MIN_SIDE}x${UNZOOM_MIN_SIDE} to find the pixel grid, so this is probably already at its native size`
-    );
-  }
-  if (width * height > UNZOOM_MAX_AREA) {
-    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 mkdir5(path18.dirname(out), { recursive: true });
-  await writeFile5(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 = path18.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 (existsSync12(file)) throw new Error(`${file} already exists; pass --force to replace it`);
-    }
-  }
-  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  const interval = opts.intervalMs ?? 5e3;
-  const timeout = opts.timeoutMs ?? 10 * 6e4;
-  const submitted = await client2.generateFontPro({
-    description: opts.description,
-    weight: opts.weight,
-    glyphPx: opts.glyphPx,
-    seed: opts.seed,
-    fontName: opts.fontName
-  });
-  const jobId = submitted.background_job_id;
-  const started = Date.now();
-  for (; ; ) {
-    const job = await client2.getFontJob(jobId);
-    opts.onProgress?.(job.status);
-    if (job.status === "failed") throw new Error(`PixelLab font job ${jobId} failed upstream`);
-    if (job.status === "completed") {
-      if (!job.download_ttf_url || !job.download_atlas_url) {
-        throw new Error(`PixelLab font job ${jobId} completed without both download URLs`);
-      }
-      const [ttfBytes, atlasBytes] = await Promise.all([
-        client2.download(job.download_ttf_url),
-        client2.download(job.download_atlas_url)
-      ]);
-      await mkdir5(path18.dirname(ttf), { recursive: true });
-      await writeFile5(ttf, ttfBytes);
-      await writeFile5(atlas, atlasBytes);
-      return { jobId, ttf, atlas, glyphPx: job.glyph_px ?? null, usage: job.usage };
-    }
-    if (Date.now() - started > timeout) {
-      throw new Error(
-        `PixelLab font job ${jobId} is still ${job.status} after ${Math.round(timeout / 1e3)} s; it keeps running upstream, but this command has stopped waiting`
-      );
-    }
-    await sleep3(interval);
-  }
-}
-var PIXELATE_COST_GENERATIONS = 6;
-var PIXELATE_MAX_SIDE = 2048;
-function defaultPixelateOut(input) {
-  const ext = path18.extname(input);
-  return `${ext ? input.slice(0, -ext.length) : input}.pixel.png`;
-}
-async function pixelateFile(client2, input, opts = {}) {
-  const out = path18.resolve(opts.out ?? defaultPixelateOut(input));
-  if (path18.resolve(input) === out) throw new Error("pixelate will not overwrite its own input; pass a different --out");
-  if (existsSync12(out) && !opts.force) throw new Error(`${out} already exists; pass --force to replace it`);
-  const bytes = await readFile10(input);
-  const metadata = imageMetadata(bytes);
-  if (!metadata) throw new Error(`${input} is not a readable PNG or JPEG`);
-  const { width, height, format } = metadata;
-  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  const interval = opts.intervalMs ?? 5e3;
-  const timeout = opts.timeoutMs ?? 10 * 6e4;
-  const submitted = await client2.imageToPixelartProFlash({
-    image: { base64: bytes.toString("base64"), format },
-    description: opts.description,
-    seed: opts.seed
-  });
-  const jobId = submitted.background_job_id;
-  const started = Date.now();
-  for (; ; ) {
-    const job = await client2.getBackgroundJob(jobId);
-    opts.onProgress?.(job.status);
-    if (job.status === "failed") throw new Error(`PixelLab pixelate job ${jobId} failed upstream`);
-    if (job.status === "completed") {
-      const images = job.last_response?.images;
-      const first = Array.isArray(images) ? images[0] : void 0;
-      if (!first || typeof first.base64 !== "string" || !first.base64) {
-        throw new Error(`PixelLab pixelate job ${jobId} completed without an image at last_response.images[0]`);
-      }
-      const png = Buffer.from(first.base64, "base64");
-      const size = imageMetadata(png);
-      await mkdir5(path18.dirname(out), { recursive: true });
-      await writeFile5(out, png);
-      return {
-        jobId,
-        out,
-        original: { width, height },
-        pixelated: { width: size?.width ?? Number(first.width), height: size?.height ?? Number(first.height) },
-        imageId: submitted.image_id,
-        usage: job.usage ?? null
-      };
-    }
-    if (Date.now() - started > timeout) {
-      throw new Error(
-        `PixelLab pixelate job ${jobId} is still ${job.status} after ${Math.round(timeout / 1e3)} s; it keeps running upstream, but this command has stopped waiting`
-      );
-    }
-    await sleep3(interval);
-  }
-}
-
 // src/pipeline/quality-regression.ts
 import path19 from "path";
 import { existsSync as existsSync13 } from "fs";
@@ -13446,6 +14522,7 @@ function retireGeneration(entry, retiredAt) {
     billed: entry.billed,
     provider: entry.provider,
     postprocess: entry.postprocess,
+    ...entry.terrainConnect ? { terrainConnect: entry.terrainConnect } : {},
     retiredAt
   };
 }
@@ -13537,6 +14614,9 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
     billed: generation.billed,
     provider: generation.provider,
     postprocess: generation.postprocess,
+    // A connected set comes back with the connection it was drawn from, so
+    // the plan compares the restored generation, not the one it replaced.
+    terrainConnect: generation.terrainConnect,
     history
   });
   await saveLock(lockPath, lock);
@@ -14557,6 +15637,22 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
     const submittedAt = resumesCheckpoint ? previousEntry.submittedAt : (/* @__PURE__ */ new Date()).toISOString();
     const history = historyAfterReplacing(previousEntry, historyLimit(loaded.manifest), submittedAt ?? (/* @__PURE__ */ new Date()).toISOString());
     const outfitParentEntry = spec.character?.kind === "outfit" && spec.character.parentSpec ? lock.entries[lockKey(spec.character.parentSpec.styleId, spec.character.parentSpec.assetId)] : void 0;
+    const terrainLinks = {};
+    const terrainConnect = {};
+    for (const side of ["lower", "upper"]) {
+      const link = spec.terrainConnect?.[side];
+      if (!link) continue;
+      const other = lock.entries[lockKey(link.spec.styleId, link.spec.assetId)];
+      const objectId = other.objectId;
+      const terrainIds = other.providerMetadata?.[provider.id]?.terrainIds;
+      const terrainId = terrainIds?.[link.terrain];
+      terrainLinks[side] = {
+        objectId,
+        terrain: link.terrain,
+        ...typeof terrainId === "string" && terrainId ? { terrainId } : {}
+      };
+      terrainConnect[side] = { sourceAssetId: link.assetId, sourceObjectId: objectId };
+    }
     upsert(lock, key, {
       styleId: spec.styleId,
       assetId: spec.assetId,
@@ -14586,6 +15682,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
         ...spec.revision.skeletonTemplate ? { skeletonTemplate: spec.revision.skeletonTemplate } : {},
         ...spec.revision.description ? { description: spec.revision.description } : {},
         ...spec.revision.removalTask ? { removalTask: spec.revision.removalTask } : {},
+        ...spec.revision.convention ? { convention: spec.revision.convention } : {},
         ...spec.revision.driftThreshold == null ? {} : { driftThreshold: spec.revision.driftThreshold },
         ...spec.revision.subjectDescription ? { subjectDescription: spec.revision.subjectDescription } : {},
         ...spec.revision.initialPose ? { initialPose: spec.revision.initialPose } : {},
@@ -14596,6 +15693,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
         sourceSha256: mirrorSourceHash(outfitParentEntry),
         referenceSha256: spec.character.outfit.reference.sha256
       } : null,
+      terrainConnect: spec.terrainConnect ? terrainConnect : void 0,
       status: "pending",
       jobId: previousJobId ?? null,
       ...previousJobId ? { submissionComplete: false } : { submissionComplete: void 0 },
@@ -14642,6 +15740,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
         ...parentEntry?.objectId ? { parentObjectId: parentEntry.objectId } : {},
         ...anchorEntry?.objectId ? { styleObjectId: anchorEntry.objectId } : {},
         ...parentOutputs ? { parentOutputs } : {},
+        ...spec.terrainConnect ? { terrainLinks } : {},
         ...replacedMetadata ? { replacedMetadata } : {},
         ...lastGenerationMetadata ? { lastGenerationMetadata } : {},
         ...previousMetadata ? { previousMetadata } : {},
@@ -16140,6 +17239,7 @@ var NewAssetSchema = z8.object({
       /** A short description of the foreground, sent as PixelLab's text hint. */
       description: z8.string().min(1).optional()
     }).strict(),
+    z8.object({ mode: z8.literal("normal-map"), from: z8.string().min(1), convention: NormalMapConventionSchema.optional() }).strict(),
     z8.object({
       mode: z8.enum(["animate", "animate-pixminimax"]),
       from: z8.string().min(1),
@@ -19618,6 +20718,12 @@ export {
   MapScenePlacementSchema,
   MapSceneSchema,
   MediaType,
+  NORMAL_MAP_CONVENTIONS,
+  NORMAL_MAP_COST_GENERATIONS,
+  NORMAL_MAP_MAX_FRAMES,
+  NORMAL_MAP_MAX_SIDE,
+  NORMAL_MAP_MIN_SIDE,
+  NormalMapConventionSchema,
   OverwriteRefusedError,
   PIXELATE_COST_GENERATIONS,
   PIXELATE_MAX_SIDE,
@@ -19645,12 +20751,17 @@ export {
   ScenarioProvider,
   StyleInputSchema,
   StyleSchema,
+  TerrainConnectSchema,
+  TerrainLinkSchema,
+  TerrainSideSchema,
   UNZOOM_MAX_AREA,
   UNZOOM_MIN_SIDE,
   UiElementSchema,
   UiPieceSchema,
   UnsupportedCapabilityError,
   UsageError,
+  VFX_ARTISTS,
+  VFX_ARTIST_MAX_SPRITE,
   VFX_TOOL,
   VfxPartSchema,
   WorkspaceProjectSchema,
@@ -19683,6 +20794,7 @@ export {
   createProvider,
   currentEntryOutputPath,
   currentOutputPath,
+  defaultNormalMapOut,
   defaultOpenCommand,
   defaultPixelateOut,
   defaultUnzoomOut,
@@ -19744,6 +20856,7 @@ export {
   loadWorkspace,
   lockKey,
   makeVfx,
+  makeVfxWithArtist,
   matchOrphanStyle,
   mcpClientFromEnv,
   measureBalanceChange,
@@ -19755,6 +20868,9 @@ export {
   mergePalettes,
   mountSprites,
   mountStyle,
+  normalMapFile,
+  normalMapResultPng,
+  normalMapSizeProblem,
   normalizeLockOutputPaths,
   normalizeRefinementPalette,
   normalizeTerrainTiles,
@@ -19772,6 +20888,7 @@ export {
   parseMcpBody,
   parseProFlashQuote,
   parseTerrainDescriptions,
+  parseVfxArtistResult,
   parseVfxExport,
   parseVfxRecipe,
   parseVfxStep,
@@ -19795,6 +20912,7 @@ export {
   readHandEditCompanion,
   readQualityBaseline,
   readSavedVfxRecipe,
+  readVfxConversation,
   readVfxRecipe,
   recipeDigest,
   referencedHashes,
@@ -19857,6 +20975,7 @@ export {
   submit,
   summarize,
   tagAdopted,
+  terrainCost,
   terrainTileCount,
   tileFeatureOutputCount,
   tileVariationCount,
@@ -19870,6 +20989,13 @@ export {
   validateWorkspace,
   verifyArtifactBundle,
   verifyRecipe,
+  vfxArtistCeiling,
+  vfxArtistFiles,
+  vfxArtistFrameFacts,
+  vfxArtistQuote,
+  vfxArtistSprite,
+  vfxAtlasFrames,
+  vfxJobFailure,
   vfxOutputPaths,
   vfxRecipeSha256,
   withArtifactManifest,