pixelkiln 0.50.0 → 0.52.0

package/dist/cli.js

@@ -707,7 +707,7 @@ import path2 from "path";
 // src/types.ts
 import { z } from "zod";
 var MediaTypeSchema = z.enum(["image/png", "image/gif"]);
-var GeneratorSchema = z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character"]);
+var GeneratorSchema = z.enum(["1dir", "map", "pixflux", "tiles", "animation", "frames", "character", "terrain", "imagePro"]);
 var GridConfidenceSchema = z.enum(["low", "medium", "high"]);
 var RevisionModeSchema = z.enum(["image-to-image", "inpaint", "outpaint"]);
 function tileVariationCount(descriptions) {
@@ -729,6 +729,7 @@ function candidateCount(size) {
 }
 function generationCost(width, height, generator = "map") {
   if (generator === "map" || generator === "pixflux") return 1;
+  if (generator === "imagePro") return 40;
   const px = width * height;
   if (px <= 1024) return 20;
   if (px <= 2048) return 25;
@@ -740,6 +741,14 @@ function tilesCost(tileSize, variations) {
   if (px <= 2048) return 25;
   return 40;
 }
+function terrainTileCount(transitionSize) {
+  return transitionSize === 1 ? 25 : 16;
+}
+function parseTerrainDescriptions(prompt) {
+  const parts = prompt.split(/\d+\s*\)\s*\./).map((part) => part.trim()).filter(Boolean);
+  if (parts.length < 2) return null;
+  return { lower: parts[0], upper: parts[1], transition: parts[2] };
+}
 var StyleImageSchema = z.object({
   /** Path to a PNG/JPEG, relative to the manifest; the active provider validates limits. */
   path: z.string()
@@ -1019,6 +1028,48 @@ var StyleObjectSchema = z.object({
    * rather than inheriting.
    */
   outlineMode: z.enum(["outline", "segmentation"]).optional(),
+  /**
+   * `terrain` generator only. Edge length of one tile in pixels. 16 or 32
+   * work in both modes; 64 needs `terrainMode: "pro"`. The API default is
+   * 16. See `parseTerrainDescriptions` for how an asset's `prompt` becomes
+   * the lower/upper/transition terrain descriptions this endpoint wants.
+   */
+  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`.
+   */
+  terrainMode: z.enum(["standard", "pro"]).optional(),
+  /**
+   * `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`.
+   */
+  terrainShapeStyle: z.enum(["square", "round"]).optional(),
+  /** `terrain` generator only, `terrainMode: "pro"`. Boundary spread
+   *  between terrains (0 = steep, 1 = gradual). API default 0.5. */
+  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. */
+  terrainSlopeSize: z.number().min(0).max(1).optional(),
+  /** `terrain` generator only, `terrainMode: "pro"`. Terrain boundary
+   *  noise (0 = smooth, 1 = rough). API default 0. */
+  terrainRaggedness: z.number().min(0).max(1).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.
+   */
+  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(),
   /**
    * `pixflux` only. Whether to strip the generated background.
    *
@@ -1132,7 +1183,7 @@ var StyleSchema = StyleObjectSchema.refine((s) => !(s.tileFeature && s.styleImag
   message: "tileFeature and styleImages cannot be combined; a connectable set derives its own tile geometry, so remove one or the other",
   path: ["tileFeature"]
 }).superRefine((style, ctx) => {
-  if (style.quality && (style.generator === "tiles" || style.generator === "animation")) {
+  if (style.quality && (style.generator === "tiles" || style.generator === "terrain" || style.generator === "animation")) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
       message: "quality profiles currently support single-image generators only",
@@ -1177,7 +1228,7 @@ var AssetSchema = z.object({
   prompt: z.string().optional(),
   /** Subdirectory under the style's outDir. Optional. */
   category: z.string().optional(),
-  /** Overrides the style default. `map` generator only. */
+  /** Overrides the style default. `map`, `pixflux`, and `imagePro` only. */
   width: z.number().int().min(16).max(8192).optional(),
   height: z.number().int().min(16).max(8192).optional(),
   /** Overrides the style default. `1dir` generator only. */
@@ -5157,6 +5208,11 @@ var MapSubmitSchema = z2.object({
   object_id: z2.string().min(1),
   status: z2.string().default("processing")
 }).passthrough();
+var UsageSchema = z2.object({
+  type: z2.string().optional(),
+  usd: z2.number().nullable().optional(),
+  generations: z2.number().nullable().optional()
+}).passthrough().nullable().optional();
 var TilesSubmitSchema = z2.object({
   tile_id: z2.string().min(1),
   background_job_id: z2.string().min(1),
@@ -5167,6 +5223,32 @@ var TilesProSchema = z2.object({
   kind: z2.string().nullable().default(null),
   tile_rules: z2.record(z2.unknown()).nullable().optional()
 }).passthrough();
+var TilesetSubmitSchema = z2.object({
+  tileset_id: z2.string().min(1),
+  background_job_id: z2.string().min(1),
+  status: z2.literal("processing").default("processing")
+}).passthrough();
+var TilesetTileSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string(),
+  image: z2.object({ base64: z2.string().min(1), format: z2.string().default("png") }).passthrough(),
+  corners: z2.object({ NW: z2.string(), NE: z2.string(), SW: z2.string(), SE: z2.string() }).passthrough(),
+  pattern_4x4: z2.object({
+    row_0: z2.array(z2.number()),
+    row_1: z2.array(z2.number()),
+    row_2: z2.array(z2.number()),
+    row_3: z2.array(z2.number())
+  }).passthrough()
+}).passthrough();
+var TilesetGetSchema = z2.object({
+  tileset: z2.object({
+    total_tiles: z2.number().int().min(1),
+    tile_size: z2.object({ width: z2.number().int().positive(), height: z2.number().int().positive() }).passthrough(),
+    terrain_types: z2.array(z2.string()),
+    tiles: z2.array(TilesetTileSchema).min(1)
+  }).passthrough(),
+  usage: UsageSchema
+}).passthrough();
 var RevisionJobSubmitSchema = z2.object({
   background_job_id: z2.string().min(1),
   status: z2.string().default("processing")
@@ -5198,11 +5280,6 @@ var MapObjectSchema = z2.object({
 var ObjectListSchema = z2.object({ objects: z2.array(PixelLabObjectSchema), total: z2.number().int().min(0) }).passthrough();
 var PixfluxResponseSchema = z2.object({ image: z2.object({ base64: z2.string().min(1) }).passthrough(), usage: z2.unknown().optional() }).passthrough();
 var SelectFramesSchema = z2.object({ created_object_ids: z2.array(z2.string()) }).passthrough();
-var UsageSchema = z2.object({
-  type: z2.string().optional(),
-  usd: z2.number().nullable().optional(),
-  generations: z2.number().nullable().optional()
-}).passthrough().nullable().optional();
 var CharacterSubmitSchema = z2.object({
   background_job_id: z2.string().min(1),
   character_id: z2.string().min(1),
@@ -5418,6 +5495,45 @@ var PixelLabClient = class {
       "get tiles"
     );
   }
+  /**
+   * `/create-tileset`: two named terrain levels (`lower`/`upper`) and the
+   * transition between them, laid out as a Wang corner set. Unlike
+   * `/create-tiles-pro`, the descriptions are separate fields the API itself
+   * places on the terrain vertex grid, not one prompt it splits by number.
+   */
+  async createTileset(args) {
+    const body = {
+      lower_description: args.lowerDescription,
+      upper_description: args.upperDescription
+    };
+    if (args.transitionDescription) body.transition_description = args.transitionDescription;
+    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.transitionSize != null) body.transition_size = args.transitionSize;
+    if (args.view) body.view = args.view;
+    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", { method: "POST", body: JSON.stringify(body) }),
+      "create tileset"
+    );
+  }
+  /** Throws PixelLabError(423) while the set is still drawing; see Tileset. */
+  async getTileset(tilesetId) {
+    const res = await validateResponse(
+      TilesetGetSchema,
+      await this.request(`/tilesets/${tilesetId}`),
+      "get tileset"
+    );
+    return { tileset: res.tileset, usage: res.usage ?? null };
+  }
   /**
    * Synchronous single-image generation. Returns the PNG inline rather than a
    * job id, and is the only endpoint that honours a forced palette;
@@ -5718,6 +5834,34 @@ var PixelLabClient = class {
       "edit-images-v2"
     );
   }
+  /**
+   * PixelLab's Pro image tier, `/generate-image-v2`: a flat 40 generations
+   * (docs/ENDPOINTS.md, "Single-image generators, measured") for real style
+   * transfer and non-square canvases up to 792x688, where `pixflux` is
+   * limited to 400x400 and no style reference. Like a revision, this hands
+   * back a plain background job with no resource of its own; unlike a
+   * revision, one call returns several candidate images to pick from (the
+   * same 4/16/64-by-size tiering as `1dir`), not a single result, and its
+   * completed shape has not been exercised live yet — `pollImagePro` in
+   * pixellab.ts fails loudly rather than guess if `last_response.images`
+   * turns out not to be the real field name.
+   *
+   * Reference images and a style image (`reference_images`, `style_image` +
+   * `style_options`) exist on this endpoint but are not modeled here yet.
+   */
+  async createImagePro(args) {
+    const body = {
+      description: args.description,
+      image_size: { width: args.width, height: args.height }
+    };
+    if (args.noBackground != null) body.no_background = args.noBackground;
+    if (args.seed != null) body.seed = args.seed;
+    return validateResponse(
+      RevisionJobSubmitSchema,
+      await this.request("/generate-image-v2", { method: "POST", body: JSON.stringify(body) }),
+      "generate-image-v2"
+    );
+  }
   async getBackgroundJob(jobId) {
     const raw = await this.request(`/background-jobs/${encodeURIComponent(jobId)}`);
     return validateResponse(BackgroundJobSchema, raw, "background-jobs/{id}");
@@ -5856,7 +6000,7 @@ var PixelLabProvider = class _PixelLabProvider {
     return new _PixelLabProvider(new PixelLabClient("download-only"));
   }
   supports(generator) {
-    return generator === "1dir" || generator === "map" || generator === "pixflux" || generator === "tiles" || generator === "character";
+    return generator === "1dir" || generator === "map" || generator === "pixflux" || generator === "tiles" || generator === "terrain" || generator === "imagePro" || generator === "character";
   }
   /**
    * `inpaint` (`/inpaint-v3`, a mask) and `image-to-image` (`/edit-images-v2`,
@@ -5892,7 +6036,7 @@ var PixelLabProvider = class _PixelLabProvider {
       const height = spec.revision.sourceHeight ?? spec.height;
       return { unit: "generations", amount: generationCost(width, height, "1dir"), candidates: 1 };
     }
-    if (spec.generator === "tiles") {
+    if (spec.generator === "tiles" || spec.generator === "terrain") {
       return { unit: "generations", amount: spec.cost, candidates: spec.candidates };
     }
     if (spec.generator === "character") {
@@ -5901,7 +6045,7 @@ var PixelLabProvider = class _PixelLabProvider {
     return {
       unit: "generations",
       amount: generationCost(spec.width, spec.height, spec.generator),
-      candidates: spec.generator === "1dir" ? candidateCount(spec.size) : 1
+      candidates: spec.generator === "1dir" || spec.generator === "imagePro" ? candidateCount(spec.size) : 1
     };
   }
   validate(spec, styleImages) {
@@ -5917,6 +6061,11 @@ var PixelLabProvider = class _PixelLabProvider {
     if ((spec.generator === "map" || spec.generator === "pixflux") && (spec.width < 16 || spec.height < 16 || spec.width > 400 || spec.height > 400)) {
       throw new Error(`PixelLab ${spec.generator} dimensions must be between 16 and 400 pixels`);
     }
+    if (spec.generator === "imagePro" && (spec.width < 16 || spec.height < 16 || spec.width > 792 || spec.height > 688)) {
+      throw new Error(
+        `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 === "map") {
       requirePixelLabOption("view", spec.view, ["low top-down", "high top-down", "side"]);
       requirePixelLabOption("outline", spec.outline, [
@@ -5936,10 +6085,60 @@ var PixelLabProvider = class _PixelLabProvider {
         "high detail"
       ]);
     }
+    if (spec.generator === "terrain") {
+      if (spec.outline) {
+        requirePixelLabOption("outline", spec.outline, [
+          "single color black outline",
+          "single color outline",
+          "selective outline",
+          "lineless"
+        ]);
+      }
+      if (spec.shading) {
+        requirePixelLabOption("shading", spec.shading, [
+          "flat shading",
+          "basic shading",
+          "medium shading",
+          "detailed shading",
+          "highly detailed shading"
+        ]);
+      }
+      if (spec.detail) {
+        requirePixelLabOption("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.generator === "character") this.validateCharacter(spec, styleImages);
     if ((spec.generator === "map" || spec.generator === "pixflux") && styleImages.length) {
       throw new Error(`PixelLab ${spec.generator} does not support style images`);
     }
+    if (spec.generator === "terrain" && styleImages.length) {
+      throw new Error(
+        "PixelLab terrain does not support style images yet; use color_image/reference images directly against /create-tileset if this becomes a real need"
+      );
+    }
+    if (spec.generator === "imagePro" && styleImages.length) {
+      throw new Error(
+        "PixelLab imagePro does not support style images yet; /generate-image-v2's own reference_images and style_image are not modeled here"
+      );
+    }
     for (const image of styleImages) {
       if (image.width > 256 || image.height > 256) {
         throw new Error(
@@ -6302,6 +6501,36 @@ var PixelLabProvider = class _PixelLabProvider {
       });
       return { jobId: res2.tile_id, metadata: { backgroundJobId: res2.background_job_id } };
     }
+    if (spec.generator === "terrain") {
+      const res2 = await this.client.createTileset({
+        lowerDescription: spec.terrainLowerDescription,
+        upperDescription: spec.terrainUpperDescription,
+        transitionDescription: spec.terrainTransitionDescription,
+        tileSize: spec.terrainTileSize,
+        mode: spec.terrainMode,
+        shapeStyle: spec.terrainShapeStyle,
+        spreadX: spec.terrainSpreadX,
+        slopeSize: spec.terrainSlopeSize,
+        raggedness: spec.terrainRaggedness,
+        transitionSize: spec.terrainTransitionSize,
+        view: spec.terrainView,
+        outline: spec.outline,
+        shading: spec.shading,
+        detail: spec.detail,
+        seed: spec.seed
+      });
+      return { jobId: res2.tileset_id, metadata: { backgroundJobId: res2.background_job_id } };
+    }
+    if (spec.generator === "imagePro") {
+      const res2 = await this.client.createImagePro({
+        description: spec.prompt,
+        width: spec.width,
+        height: spec.height,
+        noBackground: spec.noBackground,
+        seed: spec.seed
+      });
+      return { jobId: res2.background_job_id };
+    }
     if (spec.generator === "1dir") {
       const res2 = await this.client.create1Direction({
         description: spec.prompt,
@@ -6407,6 +6636,8 @@ var PixelLabProvider = class _PixelLabProvider {
     }
     if (generator === "map") return this.pollMap(jobId, context);
     if (generator === "tiles") return this.pollTiles(jobId, Boolean(context?.tileFeature), context);
+    if (generator === "terrain") return this.pollTerrain(jobId, context);
+    if (generator === "imagePro") return this.pollImagePro(jobId);
     if (generator === "character") return this.pollCharacter(jobId, context);
     const backgroundJobId = context?.metadata?.backgroundJobId;
     const obj = await this.client.getObject(jobId);
@@ -6477,6 +6708,40 @@ var PixelLabProvider = class _PixelLabProvider {
       error: `Invalid PixelLab response for revision job ${jobId}: completed with no recognized image field (got: ${Object.keys(done).join(", ") || "no keys"}); update pollRevision in src/providers/pixellab.ts with the real shape`
     };
   }
+  /**
+   * `/generate-image-v2` hands back a plain background job, the same as a
+   * revision, but a completed one carries several candidate images to
+   * review rather than a single result: the Python client's own usage
+   * sample reads `response.images`, and `edit-images-v2` (a sibling Pro
+   * endpoint) confirmed live that its own array lands at
+   * `last_response.images` with each entry `extractBase64`-shaped, so this
+   * assumes the same field name and shape here. That assumption is
+   * UNVERIFIED for this specific endpoint — no live call has been made to
+   * it — so an unrecognized response still fails loudly rather than
+   * guessing, exactly like pollRevision.
+   */
+  async pollImagePro(jobId) {
+    const job = await this.client.getBackgroundJob(jobId);
+    if (job.status === "failed") return { status: "failed", error: "imagePro job failed upstream" };
+    if (job.status !== "completed") return { status: "processing" };
+    const billed = billedFromUsage(job.usage);
+    const done = job.last_response ?? {};
+    if (Array.isArray(done.images) && done.images.length) {
+      const urls = [];
+      for (const [index, candidate] of done.images.entries()) {
+        const base64 = extractBase64(candidate);
+        if (!base64) continue;
+        const file = path12.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+        writeFileSync(file, Buffer.from(base64, "base64"));
+        urls.push(`file://${file}`);
+      }
+      if (urls.length) return { status: "review", candidateUrls: urls, billed };
+    }
+    return {
+      status: "failed",
+      error: `Invalid PixelLab response for imagePro job ${jobId}: completed with no recognized images array (got: ${Object.keys(done).join(", ") || "no keys"}); this endpoint's completed shape has not been exercised live yet -- update pollImagePro in src/providers/pixellab.ts with the real shape`
+    };
+  }
   /**
    * Map objects need their own path because the `/map-objects/{id}` record is
    * deleted upstream roughly 8 hours after creation while the image survives in
@@ -6545,6 +6810,43 @@ var PixelLabProvider = class _PixelLabProvider {
       throw err;
     }
   }
+  /**
+   * `/create-tileset` reports progress the same way `tiles` does (423 while
+   * drawing, 200 once finished), but each tile's image comes back embedded
+   * as base64 rather than a `storage_urls` link, so it is decoded straight
+   * to a cache file the same way a revision result is (`pollRevision`). A
+   * terrain set is always a connectable Wang tileset, never independent
+   * candidates to review, so this goes straight to "ready" like a connectable
+   * `tiles` set does.
+   */
+  async pollTerrain(tilesetId, context) {
+    try {
+      const { tileset, usage } = await this.client.getTileset(tilesetId);
+      const backgroundJobId = context?.metadata?.backgroundJobId;
+      const billed = billedFromUsage(usage) ?? await this.billedForJob(backgroundJobId);
+      const sources = [];
+      const terrainTiles = [];
+      for (const [index, tile] of tileset.tiles.entries()) {
+        const slug = tile.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "tile";
+        const role = `tile-${String(index).padStart(2, "0")}-${slug}`;
+        const file = path12.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 });
+      }
+      return {
+        status: "ready",
+        objectId: tilesetId,
+        sourceUrl: sources[0]?.url ?? null,
+        sources,
+        metadata: { terrainTypes: tileset.terrain_types, terrainTiles },
+        billed
+      };
+    } catch (err) {
+      if (err instanceof PixelLabError && err.status === 423) return { status: "processing" };
+      throw err;
+    }
+  }
   async selectCandidate(jobId, index, commonTag, generator) {
     if (generator === "tiles") {
       const set = await this.client.getTilesPro(jobId);
@@ -6552,6 +6854,11 @@ var PixelLabProvider = class _PixelLabProvider {
       if (!url) throw new Error(`tiles job ${jobId} has no variation at index ${index}`);
       return { objectId: `${jobId}#${index}`, sourceUrl: url };
     }
+    if (generator === "imagePro") {
+      const file = path12.join(_PixelLabProvider.cacheDir(), `${jobId}-${index}.png`);
+      if (!existsSync7(file)) throw new Error(`imagePro 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);
     const objectId = promoted.created_object_ids?.[0];
     if (!objectId) {
@@ -7895,6 +8202,10 @@ async function resolveSpecs(loaded, filter) {
         size = asset.state?.canvas ? Math.max(asset.state.canvas.width, asset.state.canvas.height) : asset.size ?? style.size ?? 64;
         width = asset.state?.canvas?.width ?? size;
         height = asset.state?.canvas?.height ?? size;
+      } else if (generator === "terrain") {
+        size = style.terrainTileSize ?? 16;
+        width = size;
+        height = size;
       } else {
         width = asset.width ?? style.size ?? 64;
         height = asset.height ?? style.size ?? 64;
@@ -7907,12 +8218,33 @@ async function resolveSpecs(loaded, filter) {
       }
       const characterKind = asset.animation ? "animation" : asset.state ? "state" : "base";
       const subject = asset.promptByStyle[styleId] ?? asset.prompt ?? "";
-      const prompt = generator === "character" && characterKind !== "base" ? subject.trim() : [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
+      let terrainLowerDescription;
+      let terrainUpperDescription;
+      let terrainTransitionDescription;
+      let prompt;
+      if (generator === "terrain") {
+        const parsed = parseTerrainDescriptions(subject);
+        if (!parsed) {
+          throw new Error(
+            `assets.${assetId}: terrain needs "1). <lower terrain> 2). <upper terrain>" in its prompt, optionally followed by "3). <transition>"`
+          );
+        }
+        const wrap = (text) => [style.promptPrefix, text, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
+        terrainLowerDescription = wrap(parsed.lower);
+        terrainUpperDescription = wrap(parsed.upper);
+        terrainTransitionDescription = parsed.transition ? wrap(parsed.transition) : void 0;
+        prompt = subject.trim();
+      } else if (generator === "character" && characterKind !== "base") {
+        prompt = subject.trim();
+      } else {
+        prompt = [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
+      }
       const relFile = asset.file ?? path13.join(asset.category ?? "", `${assetId}.png`);
       const outFile = path13.resolve(root, style.outDir, relFile);
       const qualityOutFile = style.quality ? path13.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 base = {
         styleId,
         assetId,
@@ -7949,10 +8281,21 @@ async function resolveSpecs(loaded, filter) {
         buildingFloor2Description: generator === "tiles" ? style.buildingFloor2Description : void 0,
         buildingWallAngle: generator === "tiles" ? style.buildingWallAngle : void 0,
         outlineMode: generator === "tiles" ? style.outlineMode : void 0,
+        terrainLowerDescription: generator === "terrain" ? terrainLowerDescription : void 0,
+        terrainUpperDescription: generator === "terrain" ? terrainUpperDescription : void 0,
+        terrainTransitionDescription: generator === "terrain" ? terrainTransitionDescription : void 0,
+        terrainTileSize: generator === "terrain" ? size : void 0,
+        terrainMode: generator === "terrain" ? style.terrainMode : void 0,
+        terrainShapeStyle: generator === "terrain" ? style.terrainShapeStyle : void 0,
+        terrainSpreadX: generator === "terrain" ? style.terrainSpreadX : void 0,
+        terrainSlopeSize: generator === "terrain" ? style.terrainSlopeSize : void 0,
+        terrainRaggedness: generator === "terrain" ? style.terrainRaggedness : void 0,
+        terrainTransitionSize: generator === "terrain" ? style.terrainTransitionSize : void 0,
+        terrainView: generator === "terrain" ? style.terrainView : void 0,
         ...generator === "character" ? { character: await resolveCharacterShape(asset, style, characterKind, { root, load: loadStyleImage }) } : {},
-        cost: generator === "tiles" ? tilesCost(tileSize, tileVariations) : generationCost(width, height, generator),
+        cost: generator === "tiles" ? tilesCost(tileSize, tileVariations) : generator === "terrain" ? tilesCost(size, terrainTiles) : generationCost(width, height, generator),
         costUnit: "generations",
-        candidates: generator === "tiles" ? tileVariations : generator === "1dir" ? candidateCount(size) : 1
+        candidates: generator === "tiles" ? tileVariations : generator === "terrain" ? terrainTiles : generator === "1dir" || generator === "imagePro" ? candidateCount(size) : 1
       };
       const tags = [
         .../* @__PURE__ */ new Set([
@@ -8000,7 +8343,7 @@ async function resolveSpecs(loaded, filter) {
       if (asset.mirror) {
         if (asset.mirror === assetId) throw new Error(`assets.${assetId}: an asset cannot mirror itself`);
         const sourceSpec = await finalize(asset.mirror);
-        if (sourceSpec.generator === "tiles") {
+        if (sourceSpec.generator === "tiles" || sourceSpec.generator === "terrain") {
           throw new Error(`assets.${assetId}: a tile set cannot be mirrored; its edges carry meaning`);
         }
         if (sourceSpec.character?.kind === "animation") {