pixelkiln 0.5.0 → 0.7.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path18 from "path";
+import path19 from "path";
 import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile15 } from "fs/promises";
 
 // src/env.ts
 import { readFileSync, existsSync } from "fs";
@@ -103,532 +103,225 @@ function formatCost(unit, amount) {
   return `${amount} ${unit}`;
 }
 
-// src/providers/pixellab.ts
-import { mkdirSync, existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+// src/providers/comfyui.ts
 import { randomUUID } from "crypto";
-import os from "os";
+import { readFile as readFile2 } from "fs/promises";
 import path2 from "path";
 
-// src/client.ts
-import { z } from "zod";
-var BASE = process.env.PIXELLAB_API_BASE ?? "https://api.pixellab.ai/v2";
-var MAX_RETRIES = 4;
-var MAX_DOWNLOAD_BYTES = 64 * 1024 * 1024;
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-function shouldRetry(status) {
-  return status === 429 || status === 408 || status >= 500;
-}
-function backoffMs(attempt) {
-  const base = Math.min(1e3 * 2 ** attempt, 16e3);
-  return base + Math.floor(Math.random() * 400);
+// src/hash.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+function sha256(data) {
+  return createHash("sha256").update(data).digest("hex");
 }
-function retryAfterMs(value, now = Date.now()) {
-  if (!value) return null;
-  const seconds = Number(value);
-  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
-  const date = Date.parse(value);
-  if (!Number.isFinite(date)) return null;
-  return Math.max(0, date - now);
+async function sha256File(path20) {
+  return sha256(await readFile(path20));
 }
-var BalanceResponseSchema = z.object({
-  credits: z.object({ usd: z.number() }).passthrough(),
-  subscription: z.object({
-    generations: z.number(),
-    total: z.number(),
-    plan: z.string().nullable().optional()
-  }).passthrough()
-}).passthrough();
-var ObjectSubmitSchema = z.object({
-  background_job_id: z.string().min(1),
-  object_id: z.string().min(1),
-  status: z.string().default("queued"),
-  n_frames: z.number().int().min(0)
-}).passthrough();
-var MapSubmitSchema = z.object({
-  background_job_id: z.string().min(1),
-  object_id: z.string().min(1),
-  status: z.string().default("processing")
-}).passthrough();
-var TilesSubmitSchema = z.object({
-  tile_id: z.string().min(1),
-  background_job_id: z.string().min(1),
-  status: z.literal("processing").default("processing")
-}).passthrough();
-var TilesProSchema = z.object({
-  storage_urls: z.record(z.string()),
-  kind: z.string().nullable().default(null),
-  tile_rules: z.record(z.unknown()).nullable().optional()
-}).passthrough();
-var PixelLabObjectSchema = z.object({
-  id: z.string().min(1),
-  name: z.string().nullable().default(null),
-  prompt: z.string().default(""),
-  size: z.object({ width: z.number().int().positive(), height: z.number().int().positive() }),
-  directions: z.number().default(0),
-  created_at: z.string(),
-  view: z.string().nullable().default(null),
-  preview_url: z.string().nullable().optional(),
-  rotation_urls: z.record(z.string().nullable()).nullable().optional(),
-  frame_urls: z.array(z.string()).nullable().optional(),
-  tags: z.array(z.string()).default([]),
-  status: z.string().nullable().default(null),
-  progress_percent: z.number().nullable().optional(),
-  eta_seconds: z.number().nullable().optional()
-}).passthrough();
-var MapObjectSchema = z.object({
-  object_id: z.string().min(1),
-  status: z.string(),
-  description: z.string().nullable().default(null),
-  width: z.number().nullable().default(null),
-  height: z.number().nullable().default(null),
-  download_url: z.string().nullable().default(null)
-}).passthrough();
-var ObjectListSchema = z.object({ objects: z.array(PixelLabObjectSchema), total: z.number().int().min(0) }).passthrough();
-var PixfluxResponseSchema = z.object({ image: z.object({ base64: z.string().min(1) }).passthrough(), usage: z.unknown().optional() }).passthrough();
-var SelectFramesSchema = z.object({ created_object_ids: z.array(z.string()) }).passthrough();
-function validateResponse(schema, raw, operation) {
-  const parsed = schema.safeParse(raw);
-  if (parsed.success) return parsed.data;
-  const issues = parsed.error.issues.slice(0, 4).map((i) => `${i.path.join(".") || "response"}: ${i.message}`).join("; ");
-  throw new Error(`Invalid PixelLab response for ${operation}: ${issues}`);
+function specHash(spec, styleImageHashes, providerOptionIdentity = spec.providerOptions) {
+  return sha256(
+    JSON.stringify({
+      // Preserve every existing PixelLab hash while making a provider switch
+      // invalidate the spec. Older manifests implicitly mean pixellab.
+      provider: spec.provider === "pixellab" ? void 0 : spec.provider,
+      providerOptions: providerOptionIdentity && (typeof providerOptionIdentity !== "object" || Object.keys(providerOptionIdentity).length > 0) ? providerOptionIdentity : void 0,
+      generator: spec.generator,
+      prompt: spec.prompt,
+      width: spec.width,
+      height: spec.height,
+      view: spec.view,
+      outline: spec.outline ?? null,
+      shading: spec.shading ?? null,
+      detail: spec.detail ?? null,
+      seed: spec.seed ?? null,
+      palette: spec.palette,
+      // `noBackground` only reaches the wire for pixflux; the tile fields are
+      // undefined for every other generator. `tileSize` is intentionally
+      // absent — width/height are derived from it, so it is already covered.
+      noBackground: spec.generator === "pixflux" || spec.provider !== "pixellab" ? spec.noBackground : void 0,
+      tileType: spec.tileType,
+      tileView: spec.tileView,
+      tileFeature: spec.tileFeature,
+      outlineMode: spec.outlineMode,
+      styleImages: styleImageHashes
+    })
+  );
 }
-var PixelLabError = class extends Error {
-  constructor(message2, status, body) {
-    super(message2);
-    this.status = status;
-    this.body = body;
-    this.name = "PixelLabError";
-  }
-  status;
-  body;
-};
-var PixelLabClient = class {
-  constructor(apiKey, timeoutMs = 12e4) {
-    this.apiKey = apiKey;
-    this.timeoutMs = timeoutMs;
-    if (!apiKey) throw new Error("PIXELLAB_API_KEY is required");
+
+// src/png.ts
+import { deflateSync, inflateSync } from "zlib";
+var SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var MAX_DECODED_BYTES = 256 * 1024 * 1024;
+var CHANNELS = /* @__PURE__ */ new Map([
+  [0, 1],
+  // greyscale
+  [2, 3],
+  // RGB
+  [3, 1],
+  // indexed colour
+  [4, 2],
+  // greyscale + alpha
+  [6, 4]
+  // RGBA
+]);
+var LEGAL_DEPTHS = /* @__PURE__ */ new Map([
+  [0, /* @__PURE__ */ new Set([1, 2, 4, 8, 16])],
+  [2, /* @__PURE__ */ new Set([8, 16])],
+  [3, /* @__PURE__ */ new Set([1, 2, 4, 8])],
+  [4, /* @__PURE__ */ new Set([8, 16])],
+  [6, /* @__PURE__ */ new Set([8, 16])]
+]);
+function decodePng(buf) {
+  if (buf.length < 8 || !buf.subarray(0, 8).equals(SIGNATURE)) {
+    throw new Error("not a PNG");
   }
-  apiKey;
-  timeoutMs;
-  /**
-   * Retries only what is safe to retry: transport failures, 429, and 5xx.
-   * A 4xx other than 429 is a bad request and retrying it just wastes time.
-   *
-   * POSTs that create objects are included, which is a deliberate trade: the
-   * failure mode of not retrying (a dropped asset in a 65-item run) is more
-   * common than the failure mode of retrying (a duplicate object), and a
-   * duplicate is visible and free to delete whereas a silent gap is neither.
-   */
-  async request(path19, init, attempt = 0) {
-    const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    let res;
-    try {
-      res = await fetch(`${BASE}${path19}`, {
-        ...init,
-        signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
-        headers: {
-          Authorization: auth,
-          "Content-Type": "application/json",
-          ...init?.headers ?? {}
-        }
-      });
-    } catch (err) {
-      if (attempt < MAX_RETRIES) {
-        await sleep(backoffMs(attempt));
-        return this.request(path19, init, attempt + 1);
-      }
-      throw err;
-    }
-    if (!res.ok && shouldRetry(res.status) && attempt < MAX_RETRIES) {
-      const waitMs = retryAfterMs(res.headers.get("retry-after")) ?? backoffMs(attempt);
-      await sleep(waitMs);
-      return this.request(path19, init, attempt + 1);
+  let header = null;
+  let palette = null;
+  let transparency = null;
+  let sawImageData = false;
+  let sawEnd = false;
+  const idat = [];
+  let offset = 8;
+  while (offset < buf.length) {
+    if (offset + 12 > buf.length) throw new Error("truncated PNG chunk header");
+    const length = buf.readUInt32BE(offset);
+    const type = buf.toString("ascii", offset + 4, offset + 8);
+    if (!/^[A-Za-z]{4}$/.test(type) || /[a-z]/.test(type[2])) {
+      throw new Error(`PNG has an invalid chunk type ${JSON.stringify(type)}`);
     }
-    const text = await res.text();
-    if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path19} \u2192 ${res.status}`, res.status, text);
+    const end = offset + 12 + length;
+    if (!Number.isSafeInteger(end) || end > buf.length) {
+      throw new Error(`truncated PNG chunk ${type || "(unknown)"}`);
     }
-    if (!text) return {};
-    try {
-      return JSON.parse(text);
-    } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path19} returned invalid JSON`);
+    const data = buf.subarray(offset + 8, offset + 8 + length);
+    const expectedCrc = buf.readUInt32BE(offset + 8 + length);
+    const actualCrc = crc32(buf.subarray(offset + 4, offset + 8 + length)) >>> 0;
+    if (actualCrc !== expectedCrc) throw new Error(`PNG chunk ${type} has an invalid checksum`);
+    if (!header && type !== "IHDR") throw new Error("PNG is missing its leading IHDR chunk");
+    if (type === "IHDR") {
+      if (header) throw new Error("PNG has more than one IHDR chunk");
+      if (data.length !== 13) throw new Error("PNG has an invalid IHDR chunk");
+      const width = data.readUInt32BE(0);
+      const height = data.readUInt32BE(4);
+      const bitDepth = data[8];
+      const colorType = data[9];
+      const channels = CHANNELS.get(colorType);
+      if (!width || !height) throw new Error("PNG dimensions must be positive");
+      if (!channels || !LEGAL_DEPTHS.get(colorType)?.has(bitDepth)) {
+        throw new Error(`unsupported PNG: bitDepth=${bitDepth} colorType=${colorType}`);
+      }
+      if (data[10] !== 0) throw new Error(`unsupported PNG compression method ${data[10]}`);
+      if (data[11] !== 0) throw new Error(`unsupported PNG filter method ${data[11]}`);
+      if (data[12] !== 0) throw new Error("unsupported PNG: interlaced");
+      header = { width, height, bitDepth, colorType, channels };
+    } else if (type === "PLTE") {
+      if (sawImageData) throw new Error("PNG palette appears after image data");
+      if (palette) throw new Error("PNG has more than one palette");
+      if (!data.length || data.length % 3 !== 0 || data.length > 256 * 3) {
+        throw new Error("PNG has an invalid palette");
+      }
+      palette = Buffer.from(data);
+    } else if (type === "tRNS") {
+      if (sawImageData) throw new Error("PNG transparency appears after image data");
+      if (transparency) throw new Error("PNG has more than one transparency chunk");
+      transparency = Buffer.from(data);
+    } else if (type === "IDAT") {
+      sawImageData = true;
+      idat.push(data);
+    } else if (type === "IEND") {
+      if (data.length !== 0) throw new Error("PNG has an invalid IEND chunk");
+      sawEnd = true;
+      break;
+    } else if (/^[A-Z]/.test(type)) {
+      throw new Error(`unsupported critical PNG chunk ${type}`);
     }
+    offset = end;
   }
-  async balance() {
-    const raw = validateResponse(BalanceResponseSchema, await this.request("/balance"), "balance");
-    return {
-      usd: raw.credits?.usd ?? 0,
-      generations: raw.subscription?.generations ?? 0,
-      total: raw.subscription?.total ?? 0,
-      plan: raw.subscription?.plan ?? "unknown"
-    };
-  }
-  /**
-   * Square objects that persist indefinitely.
-   *
-   * `size` and `styleImages` are mutually exclusive at the API level: when style
-   * images are supplied the largest one dictates the output size. So style
-   * references must already be at the target resolution — a 128px reference
-   * silently produces 128px output and a different candidate count.
-   */
-  async create1Direction(args) {
-    const body = { description: args.description };
-    if (args.styleImages?.length) {
-      body.style_images = args.styleImages.map(({ base64, format }) => ({
-        type: "base64",
-        base64,
-        format
-      }));
-    } else if (args.size != null) {
-      body.size = args.size;
-    }
-    if (args.view) body.view = args.view;
-    if (args.itemDescriptions?.length) body.item_descriptions = args.itemDescriptions;
-    const raw = await this.request("/create-1-direction-object", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
-    const parsed = validateResponse(ObjectSubmitSchema, raw, "create-1-direction-object");
-    return parsed;
-  }
-  /**
-   * Arbitrary width x height. Returns a single result — no selection step.
-   *
-   * These AUTO-DELETE AFTER 8 HOURS, so `fetch` must run in the same session as
-   * `submit`. The pipeline warns when a map-object entry is older than that.
-   */
-  async createMapObject(args) {
-    const body = {
-      description: args.description,
-      image_size: { width: args.width, height: args.height }
-    };
-    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(
-      MapSubmitSchema,
-      await this.request("/map-objects", { method: "POST", body: JSON.stringify(body) }),
-      "create map object"
-    );
-  }
-  /**
-   * Draws a whole tile set in one call — many variations, or a connectable
-   * set when `tileFeature` is given.
-   *
-   * `styleImages` here is NOT the shape `create-1-direction-object` uses.
-   * TilesProStyleImage is flat — `{base64, width, height}`, all three
-   * required — where 1dir wants `{type, base64, format}`. Confirmed against
-   * the OpenAPI schema; sending 1dir's shape is rejected as an extra field.
-   *
-   * Passing style images also makes the API ignore `tileType` and `tileView`
-   * and copy the reference's tile geometry instead.
-   */
-  async createTilesPro(args) {
-    const body = { description: args.description };
-    if (args.tileSize != null) body.tile_size = args.tileSize;
-    if (args.tileType) body.tile_type = args.tileType;
-    if (args.tileView) body.tile_view = args.tileView;
-    if (args.tileFeature) body.tile_feature = args.tileFeature;
-    if (args.outlineMode) body.outline_mode = args.outlineMode;
-    if (args.seed != null) body.seed = args.seed;
-    if (args.styleImages?.length) body.style_images = args.styleImages;
-    return validateResponse(
-      TilesSubmitSchema,
-      await this.request("/create-tiles-pro", { method: "POST", body: JSON.stringify(body) }),
-      "create tiles"
-    );
-  }
-  /** Throws PixelLabError(423) while the set is still drawing — see TilesPro. */
-  async getTilesPro(tileId) {
-    return validateResponse(
-      TilesProSchema,
-      await this.request(`/tiles-pro/${tileId}`),
-      "get tiles"
-    );
+  if (!header) throw new Error("PNG has no image header");
+  if (!sawEnd) throw new Error("PNG has no IEND chunk");
+  if (!idat.length) throw new Error("PNG has no image data");
+  validatePalette(header, palette);
+  validateTransparency(header.colorType, transparency, palette);
+  const bitsPerPixel = header.channels * header.bitDepth;
+  const stride = Math.ceil(header.width * bitsPerPixel / 8);
+  const rawLength = (stride + 1) * header.height;
+  const rgbaLength = header.width * header.height * 4;
+  if (!Number.isSafeInteger(rawLength) || !Number.isSafeInteger(rgbaLength) || rawLength > MAX_DECODED_BYTES || rgbaLength > MAX_DECODED_BYTES) {
+    throw new Error("PNG dimensions exceed the 256 MiB decoded-image limit");
   }
-  /**
-   * Synchronous single-image generation. Returns the PNG inline rather than a
-   * job id, and is the only endpoint that honours a forced palette —
-   * `color_image` on /map-objects returns a 500 whatever the payload shape.
-   */
-  async createImagePixflux(args) {
-    const body = {
-      description: args.description,
-      image_size: { width: args.width, height: args.height },
-      no_background: args.noBackground ?? true
-    };
-    if (args.paletteSwatchBase64) {
-      body.color_image = { type: "base64", base64: args.paletteSwatchBase64, format: "png" };
-    }
-    if (args.seed != null) body.seed = args.seed;
-    const res = validateResponse(
-      PixfluxResponseSchema,
-      await this.request("/create-image-pixflux", {
-        method: "POST",
-        body: JSON.stringify(body)
-      }),
-      "create pixflux image"
-    );
-    const b64 = res.image.base64;
-    return { png: Buffer.from(b64, "base64"), usage: res.usage };
+  let raw;
+  try {
+    raw = inflateSync(Buffer.concat(idat), { maxOutputLength: rawLength });
+  } catch (err) {
+    throw new Error(`invalid PNG image data: ${err instanceof Error ? err.message : String(err)}`);
   }
-  async getObject(objectId) {
-    return validateResponse(
-      PixelLabObjectSchema,
-      await this.request(`/objects/${objectId}`),
-      "get object"
-    );
+  if (raw.length !== rawLength) {
+    throw new Error(`invalid PNG image data length: expected ${rawLength}, got ${raw.length}`);
   }
-  async getMapObject(objectId) {
-    return validateResponse(
-      MapObjectSchema,
-      await this.request(`/map-objects/${objectId}`),
-      "get map object"
-    );
+  const filterBytes = Math.max(1, Math.ceil(bitsPerPixel / 8));
+  const samples = unfilter(raw, stride, header.height, filterBytes);
+  return {
+    width: header.width,
+    height: header.height,
+    pixels: toRgba(samples, header, stride, palette, transparency)
+  };
+}
+function validatePalette(header, palette) {
+  if (header.colorType === 3 && !palette) throw new Error("indexed PNG has no palette");
+  if ((header.colorType === 0 || header.colorType === 4) && palette) {
+    throw new Error("greyscale PNG cannot contain a palette");
   }
-  async listObjects(limit = 50, offset = 0) {
-    return validateResponse(
-      ObjectListSchema,
-      await this.request(`/objects?limit=${limit}&offset=${offset}`),
-      "list objects"
-    );
+  if (header.colorType === 3 && palette && palette.length / 3 > 2 ** header.bitDepth) {
+    throw new Error("indexed PNG palette has more entries than its bit depth permits");
   }
-  /** Walks the whole account. Used by `adopt` to reconcile orphaned objects. */
-  async *iterateObjects(pageSize = 100) {
-    let offset = 0;
-    for (; ; ) {
-      const page = await this.listObjects(pageSize, offset);
-      for (const obj of page.objects) yield obj;
-      offset += page.objects.length;
-      if (page.objects.length === 0 || offset >= page.total) return;
+}
+function unfilter(raw, stride, height, bpp) {
+  const out = Buffer.alloc(stride * height);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)];
+    const src = raw.subarray(y * (stride + 1) + 1, y * (stride + 1) + 1 + stride);
+    const dst = out.subarray(y * stride, (y + 1) * stride);
+    const prev = y > 0 ? out.subarray((y - 1) * stride, y * stride) : null;
+    for (let x = 0; x < stride; x++) {
+      const a = x >= bpp ? dst[x - bpp] : 0;
+      const b = prev ? prev[x] : 0;
+      const c = prev && x >= bpp ? prev[x - bpp] : 0;
+      const v = src[x];
+      switch (filter) {
+        case 0:
+          dst[x] = v;
+          break;
+        case 1:
+          dst[x] = v + a & 255;
+          break;
+        case 2:
+          dst[x] = v + b & 255;
+          break;
+        case 3:
+          dst[x] = v + (a + b >> 1) & 255;
+          break;
+        case 4:
+          dst[x] = v + paeth(a, b, c) & 255;
+          break;
+        default:
+          throw new Error(`unknown PNG filter ${filter} on row ${y}`);
+      }
     }
   }
-  /**
-   * Promotes chosen candidates to standalone objects, each with its own id.
-   * The review parent survives until nothing is left in it, so the returned
-   * `created_object_ids` — not the parent id — is what should be recorded.
-   */
-  async selectFrames(objectId, indices, commonTag) {
-    const raw = await this.request(`/objects/${objectId}/select-frames`, {
-      method: "POST",
-      body: JSON.stringify(commonTag ? { indices, common_tag: commonTag } : { indices })
-    });
-    return validateResponse(SelectFramesSchema, raw, "select frames");
-  }
-  /** Irreversible. Only reached via `purge`, behind an explicit confirmation. */
-  deleteObject(objectId) {
-    return this.request(`/objects/${objectId}`, { method: "DELETE" });
+  return out;
+}
+function validateTransparency(colorType, transparency, palette) {
+  if (!transparency) return;
+  if (colorType === 0 && transparency.length !== 2) {
+    throw new Error("greyscale PNG has an invalid transparency chunk");
   }
-  dismissReview(objectId) {
-    return this.request(`/objects/${objectId}/dismiss-review`, { method: "POST" });
+  if (colorType === 2 && transparency.length !== 6) {
+    throw new Error("RGB PNG has an invalid transparency chunk");
   }
-  /** Free and synchronous. Replaces the full tag set — include tags you want to keep. */
-  setTags(objectId, tags) {
-    return this.request(`/objects/${objectId}/tags`, { method: "PATCH", body: JSON.stringify({ tags }) });
+  if (colorType === 3 && transparency.length > (palette?.length ?? 0) / 3) {
+    throw new Error("indexed PNG transparency exceeds its palette");
   }
-  /** Storage URLs are public; no auth header, and sending one can break the CDN request. */
-  async download(url) {
-    const res = await fetch(url, { signal: AbortSignal.timeout(this.timeoutMs) });
-    if (!res.ok) throw new PixelLabError(`download ${url} \u2192 ${res.status}`, res.status, "");
-    const declared = Number(res.headers.get("content-length"));
-    if (Number.isFinite(declared) && declared > MAX_DOWNLOAD_BYTES) {
-      throw new Error(`download ${url} exceeds the ${MAX_DOWNLOAD_BYTES}-byte safety limit`);
-    }
-    const buf = Buffer.from(await res.arrayBuffer());
-    if (buf.length > MAX_DOWNLOAD_BYTES) {
-      throw new Error(`download ${url} exceeds the ${MAX_DOWNLOAD_BYTES}-byte safety limit`);
-    }
-    return buf;
-  }
-};
-function clientFromEnv() {
-  const key = process.env.PIXELLAB_API_KEY;
-  if (!key) {
-    throw new Error(
-      "PIXELLAB_API_KEY is not set.\nLooked in the environment, and in .env.local / .env beside the manifest and in the current directory."
-    );
-  }
-  return new PixelLabClient(key);
-}
-
-// src/png.ts
-import { deflateSync, inflateSync } from "zlib";
-var SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
-var MAX_DECODED_BYTES = 256 * 1024 * 1024;
-var CHANNELS = /* @__PURE__ */ new Map([
-  [0, 1],
-  // greyscale
-  [2, 3],
-  // RGB
-  [3, 1],
-  // indexed colour
-  [4, 2],
-  // greyscale + alpha
-  [6, 4]
-  // RGBA
-]);
-var LEGAL_DEPTHS = /* @__PURE__ */ new Map([
-  [0, /* @__PURE__ */ new Set([1, 2, 4, 8, 16])],
-  [2, /* @__PURE__ */ new Set([8, 16])],
-  [3, /* @__PURE__ */ new Set([1, 2, 4, 8])],
-  [4, /* @__PURE__ */ new Set([8, 16])],
-  [6, /* @__PURE__ */ new Set([8, 16])]
-]);
-function decodePng(buf) {
-  if (buf.length < 8 || !buf.subarray(0, 8).equals(SIGNATURE)) {
-    throw new Error("not a PNG");
-  }
-  let header = null;
-  let palette = null;
-  let transparency = null;
-  let sawImageData = false;
-  let sawEnd = false;
-  const idat = [];
-  let offset = 8;
-  while (offset < buf.length) {
-    if (offset + 12 > buf.length) throw new Error("truncated PNG chunk header");
-    const length = buf.readUInt32BE(offset);
-    const type = buf.toString("ascii", offset + 4, offset + 8);
-    if (!/^[A-Za-z]{4}$/.test(type) || /[a-z]/.test(type[2])) {
-      throw new Error(`PNG has an invalid chunk type ${JSON.stringify(type)}`);
-    }
-    const end = offset + 12 + length;
-    if (!Number.isSafeInteger(end) || end > buf.length) {
-      throw new Error(`truncated PNG chunk ${type || "(unknown)"}`);
-    }
-    const data = buf.subarray(offset + 8, offset + 8 + length);
-    const expectedCrc = buf.readUInt32BE(offset + 8 + length);
-    const actualCrc = crc32(buf.subarray(offset + 4, offset + 8 + length)) >>> 0;
-    if (actualCrc !== expectedCrc) throw new Error(`PNG chunk ${type} has an invalid checksum`);
-    if (!header && type !== "IHDR") throw new Error("PNG is missing its leading IHDR chunk");
-    if (type === "IHDR") {
-      if (header) throw new Error("PNG has more than one IHDR chunk");
-      if (data.length !== 13) throw new Error("PNG has an invalid IHDR chunk");
-      const width = data.readUInt32BE(0);
-      const height = data.readUInt32BE(4);
-      const bitDepth = data[8];
-      const colorType = data[9];
-      const channels = CHANNELS.get(colorType);
-      if (!width || !height) throw new Error("PNG dimensions must be positive");
-      if (!channels || !LEGAL_DEPTHS.get(colorType)?.has(bitDepth)) {
-        throw new Error(`unsupported PNG: bitDepth=${bitDepth} colorType=${colorType}`);
-      }
-      if (data[10] !== 0) throw new Error(`unsupported PNG compression method ${data[10]}`);
-      if (data[11] !== 0) throw new Error(`unsupported PNG filter method ${data[11]}`);
-      if (data[12] !== 0) throw new Error("unsupported PNG: interlaced");
-      header = { width, height, bitDepth, colorType, channels };
-    } else if (type === "PLTE") {
-      if (sawImageData) throw new Error("PNG palette appears after image data");
-      if (palette) throw new Error("PNG has more than one palette");
-      if (!data.length || data.length % 3 !== 0 || data.length > 256 * 3) {
-        throw new Error("PNG has an invalid palette");
-      }
-      palette = Buffer.from(data);
-    } else if (type === "tRNS") {
-      if (sawImageData) throw new Error("PNG transparency appears after image data");
-      if (transparency) throw new Error("PNG has more than one transparency chunk");
-      transparency = Buffer.from(data);
-    } else if (type === "IDAT") {
-      sawImageData = true;
-      idat.push(data);
-    } else if (type === "IEND") {
-      if (data.length !== 0) throw new Error("PNG has an invalid IEND chunk");
-      sawEnd = true;
-      break;
-    } else if (/^[A-Z]/.test(type)) {
-      throw new Error(`unsupported critical PNG chunk ${type}`);
-    }
-    offset = end;
-  }
-  if (!header) throw new Error("PNG has no image header");
-  if (!sawEnd) throw new Error("PNG has no IEND chunk");
-  if (!idat.length) throw new Error("PNG has no image data");
-  validatePalette(header, palette);
-  validateTransparency(header.colorType, transparency, palette);
-  const bitsPerPixel = header.channels * header.bitDepth;
-  const stride = Math.ceil(header.width * bitsPerPixel / 8);
-  const rawLength = (stride + 1) * header.height;
-  const rgbaLength = header.width * header.height * 4;
-  if (!Number.isSafeInteger(rawLength) || !Number.isSafeInteger(rgbaLength) || rawLength > MAX_DECODED_BYTES || rgbaLength > MAX_DECODED_BYTES) {
-    throw new Error("PNG dimensions exceed the 256 MiB decoded-image limit");
-  }
-  let raw;
-  try {
-    raw = inflateSync(Buffer.concat(idat), { maxOutputLength: rawLength });
-  } catch (err) {
-    throw new Error(`invalid PNG image data: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  if (raw.length !== rawLength) {
-    throw new Error(`invalid PNG image data length: expected ${rawLength}, got ${raw.length}`);
-  }
-  const filterBytes = Math.max(1, Math.ceil(bitsPerPixel / 8));
-  const samples = unfilter(raw, stride, header.height, filterBytes);
-  return {
-    width: header.width,
-    height: header.height,
-    pixels: toRgba(samples, header, stride, palette, transparency)
-  };
-}
-function validatePalette(header, palette) {
-  if (header.colorType === 3 && !palette) throw new Error("indexed PNG has no palette");
-  if ((header.colorType === 0 || header.colorType === 4) && palette) {
-    throw new Error("greyscale PNG cannot contain a palette");
-  }
-  if (header.colorType === 3 && palette && palette.length / 3 > 2 ** header.bitDepth) {
-    throw new Error("indexed PNG palette has more entries than its bit depth permits");
-  }
-}
-function unfilter(raw, stride, height, bpp) {
-  const out = Buffer.alloc(stride * height);
-  for (let y = 0; y < height; y++) {
-    const filter = raw[y * (stride + 1)];
-    const src = raw.subarray(y * (stride + 1) + 1, y * (stride + 1) + 1 + stride);
-    const dst = out.subarray(y * stride, (y + 1) * stride);
-    const prev = y > 0 ? out.subarray((y - 1) * stride, y * stride) : null;
-    for (let x = 0; x < stride; x++) {
-      const a = x >= bpp ? dst[x - bpp] : 0;
-      const b = prev ? prev[x] : 0;
-      const c = prev && x >= bpp ? prev[x - bpp] : 0;
-      const v = src[x];
-      switch (filter) {
-        case 0:
-          dst[x] = v;
-          break;
-        case 1:
-          dst[x] = v + a & 255;
-          break;
-        case 2:
-          dst[x] = v + b & 255;
-          break;
-        case 3:
-          dst[x] = v + (a + b >> 1) & 255;
-          break;
-        case 4:
-          dst[x] = v + paeth(a, b, c) & 255;
-          break;
-        default:
-          throw new Error(`unknown PNG filter ${filter} on row ${y}`);
-      }
-    }
-  }
-  return out;
-}
-function validateTransparency(colorType, transparency, palette) {
-  if (!transparency) return;
-  if (colorType === 0 && transparency.length !== 2) {
-    throw new Error("greyscale PNG has an invalid transparency chunk");
-  }
-  if (colorType === 2 && transparency.length !== 6) {
-    throw new Error("RGB PNG has an invalid transparency chunk");
-  }
-  if (colorType === 3 && transparency.length > (palette?.length ?? 0) / 3) {
-    throw new Error("indexed PNG transparency exceeds its palette");
-  }
-  if (colorType === 4 || colorType === 6) {
-    throw new Error("PNG with an alpha channel cannot also contain tRNS");
+  if (colorType === 4 || colorType === 6) {
+    throw new Error("PNG with an alpha channel cannot also contain tRNS");
   }
 }
 function toRgba(samples, header, stride, palette, transparency) {
@@ -748,67 +441,921 @@ function encodeRgbPng(width, height, rgb) {
   if (rgb.length !== width * height * 3) {
     throw new Error(`expected ${width * height * 3} bytes of RGB, got ${rgb.length}`);
   }
-  const stride = width * 3;
-  const raw = Buffer.alloc((stride + 1) * height);
-  for (let y = 0; y < height; y++) {
-    raw[y * (stride + 1)] = 0;
-    rgb.copy(raw, y * (stride + 1) + 1, y * stride, (y + 1) * stride);
+  const stride = width * 3;
+  const raw = Buffer.alloc((stride + 1) * height);
+  for (let y = 0; y < height; y++) {
+    raw[y * (stride + 1)] = 0;
+    rgb.copy(raw, y * (stride + 1) + 1, y * stride, (y + 1) * stride);
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 2;
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    chunk("IHDR", ihdr),
+    chunk("IDAT", deflateSync(raw)),
+    chunk("IEND", Buffer.alloc(0))
+  ]);
+}
+function encodeRgbaPng(width, height, rgba) {
+  if (rgba.length !== width * height * 4) {
+    throw new Error(`expected ${width * height * 4} bytes of RGBA, got ${rgba.length}`);
+  }
+  const stride = width * 4;
+  const raw = Buffer.alloc((stride + 1) * height);
+  for (let y = 0; y < height; y++) {
+    raw[y * (stride + 1)] = 0;
+    rgba.copy(raw, y * (stride + 1) + 1, y * stride, (y + 1) * stride);
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    chunk("IHDR", ihdr),
+    chunk("IDAT", deflateSync(raw)),
+    chunk("IEND", Buffer.alloc(0))
+  ]);
+}
+function paletteSwatch(hexes, size = 64) {
+  const colours = hexes.map(parseHex);
+  if (!colours.length) throw new Error("palette is empty");
+  const rgb = Buffer.alloc(size * size * 3);
+  const band = Math.max(1, Math.floor(size / colours.length));
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const c = colours[Math.min(colours.length - 1, Math.floor(x / band))];
+      const o = (y * size + x) * 3;
+      rgb[o] = c.r;
+      rgb[o + 1] = c.g;
+      rgb[o + 2] = c.b;
+    }
+  }
+  return encodeRgbPng(size, size, rgb);
+}
+function parseHex(hex2) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex2.trim());
+  if (!m) throw new Error(`invalid hex colour "${hex2}" \u2014 expected #rrggbb`);
+  const n = parseInt(m[1], 16);
+  return { r: n >> 16 & 255, g: n >> 8 & 255, b: n & 255 };
+}
+
+// src/media.ts
+var MediaType = {
+  PNG: "image/png",
+  GIF: "image/gif"
+};
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+function mediaExtension(mediaType) {
+  return mediaType === MediaType.GIF ? ".gif" : ".png";
+}
+function mediaTypeFromExtension(file) {
+  const lower = file.toLowerCase();
+  if (lower.endsWith(".png")) return MediaType.PNG;
+  if (lower.endsWith(".gif")) return MediaType.GIF;
+  return null;
+}
+function detectMediaType(bytes) {
+  if (bytes.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) return MediaType.PNG;
+  const header = bytes.subarray(0, 6).toString("ascii");
+  if (header === "GIF87a" || header === "GIF89a") return MediaType.GIF;
+  return null;
+}
+function validateMedia(bytes, expected) {
+  const actual = detectMediaType(bytes);
+  if (!actual) throw new Error(`response was not a supported PNG or GIF (${bytes.length} bytes)`);
+  if (expected && actual !== expected) {
+    throw new Error(`response was ${actual}, expected ${expected}`);
+  }
+  if (actual === MediaType.PNG) {
+    decodePng(bytes);
+  } else {
+    validateGif(bytes);
+  }
+  return actual;
+}
+function validateGif(bytes) {
+  if (bytes.length < 14) throw new Error("invalid GIF: truncated logical screen descriptor");
+  const width = bytes.readUInt16LE(6);
+  const height = bytes.readUInt16LE(8);
+  if (!width || !height) throw new Error("invalid GIF: zero-sized logical screen");
+  const packed = bytes[10];
+  let offset = 13;
+  if (packed & 128) offset += 3 * 2 ** ((packed & 7) + 1);
+  if (offset > bytes.length) throw new Error("invalid GIF: truncated global color table");
+  let sawImage = false;
+  while (offset < bytes.length) {
+    const marker = bytes[offset];
+    if (marker === 59) {
+      if (!sawImage) throw new Error("invalid GIF: contains no image frame");
+      return;
+    }
+    if (marker === 44) {
+      if (offset + 10 > bytes.length) throw new Error("invalid GIF: truncated image descriptor");
+      const imagePacked = bytes[offset + 9];
+      offset += 10;
+      if (imagePacked & 128) offset += 3 * 2 ** ((imagePacked & 7) + 1);
+      if (offset >= bytes.length) throw new Error("invalid GIF: missing image data");
+      offset++;
+      offset = skipSubBlocks(bytes, offset);
+      sawImage = true;
+      continue;
+    }
+    if (marker === 33) {
+      if (offset + 2 > bytes.length) throw new Error("invalid GIF: truncated extension");
+      offset = skipSubBlocks(bytes, offset + 2);
+      continue;
+    }
+    throw new Error(`invalid GIF: unexpected block marker 0x${marker.toString(16)}`);
+  }
+  throw new Error("invalid GIF: missing trailer");
+}
+function skipSubBlocks(bytes, start) {
+  let offset = start;
+  for (; ; ) {
+    if (offset >= bytes.length) throw new Error("invalid GIF: truncated data blocks");
+    const size = bytes[offset];
+    offset++;
+    if (size === 0) return offset;
+    offset += size;
+    if (offset > bytes.length) throw new Error("invalid GIF: truncated data block");
+  }
+}
+function cacheFileName(hash, mediaType = MediaType.PNG) {
+  return `${hash}${mediaExtension(mediaType)}`;
+}
+
+// src/providers/comfyui.ts
+var DEFAULT_BASE_URL = "http://127.0.0.1:8188";
+var ComfyUIClient = class {
+  constructor(baseUrl = process.env.COMFYUI_BASE_URL ?? DEFAULT_BASE_URL, request = fetch) {
+    this.request = request;
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+  }
+  request;
+  baseUrl;
+  async checkConnection() {
+    const value = await this.json("system_stats");
+    if (!isObject(value)) throw new Error("ComfyUI returned invalid system stats");
+  }
+  async submit(workflow) {
+    const value = await this.json("prompt", {
+      method: "POST",
+      body: JSON.stringify({ prompt: workflow, client_id: randomUUID() })
+    });
+    if (!isObject(value)) throw new Error("ComfyUI returned an invalid queue response");
+    const promptId = value.prompt_id;
+    if (typeof promptId !== "string" || !promptId) {
+      const nodes = isObject(value.node_errors) ? Object.keys(value.node_errors) : [];
+      throw new Error(
+        "ComfyUI did not return a prompt id" + (nodes.length ? `; invalid workflow node(s): ${nodes.slice(0, 8).join(", ")}` : "")
+      );
+    }
+    return promptId;
+  }
+  async history(promptId) {
+    return this.json(`history/${encodeURIComponent(promptId)}`);
+  }
+  viewUrl(image) {
+    const url = this.endpoint("view");
+    url.searchParams.set("filename", image.filename);
+    url.searchParams.set("subfolder", image.subfolder);
+    url.searchParams.set("type", image.type);
+    return url.toString();
+  }
+  async download(source) {
+    let target = source;
+    if (source.startsWith("comfyui://")) target = this.viewUrl(parseSource(source));
+    const response = await this.request(target);
+    if (!response.ok) throw new Error(`ComfyUI download failed (${response.status})`);
+    return Buffer.from(await response.arrayBuffer());
+  }
+  endpoint(route) {
+    return new URL(route.replace(/^\/+/, ""), `${this.baseUrl}/`);
+  }
+  async json(route, init = {}) {
+    const url = this.endpoint(route);
+    const response = await this.request(url, {
+      ...init,
+      headers: {
+        ...init.body ? { "Content-Type": "application/json" } : {},
+        ...init.headers
+      }
+    });
+    const text = await response.text();
+    let value = null;
+    try {
+      value = text ? JSON.parse(text) : null;
+    } catch {
+      if (response.ok) throw new Error(`ComfyUI returned invalid JSON from ${url.pathname}`);
+      value = null;
+    }
+    if (!response.ok) {
+      const detail = apiError(value);
+      throw new Error(
+        `ComfyUI request failed (${response.status}) at ${url.pathname}` + (detail ? `: ${detail}` : "")
+      );
+    }
+    return value;
+  }
+};
+var ComfyUIProvider = class _ComfyUIProvider {
+  constructor(client = new ComfyUIClient()) {
+    this.client = client;
+  }
+  client;
+  id = "comfyui";
+  static fromEnv() {
+    return new _ComfyUIProvider();
+  }
+  static forOffline() {
+    return new _ComfyUIProvider(new ComfyUIClient(DEFAULT_BASE_URL));
+  }
+  static forDownloads() {
+    return new _ComfyUIProvider();
+  }
+  async resolveOptions(value, context) {
+    const options = parseOptions(value);
+    const workflowPath = path2.resolve(context.root, options.workflowFile);
+    let raw;
+    try {
+      raw = await readFile2(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)}`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new Error(`ComfyUI workflow for style "${context.styleId}" is not valid JSON: ${workflowPath}`);
+    }
+    const workflow = parseWorkflow(parsed, workflowPath);
+    validateWorkflowBindings(workflow, options);
+    const workflowSha256 = sha256(JSON.stringify(canonical(workflow)));
+    const resolved = { ...options, workflow, workflowSha256 };
+    return {
+      options: resolved,
+      identity: {
+        outputNodeId: options.outputNodeId,
+        numImages: options.numImages,
+        bindings: options.bindings,
+        workflowSha256
+      }
+    };
+  }
+  supports(generator) {
+    return generator === "map";
+  }
+  estimate(spec) {
+    return { unit: "free", amount: 0, candidates: resolvedOptions(spec).numImages };
+  }
+  validate(spec, styleImages) {
+    const options = resolvedOptions(spec);
+    if (spec.width < 16 || spec.height < 16 || spec.width > 4096 || spec.height > 4096) {
+      throw new Error("ComfyUI output dimensions must be between 16 and 4096 pixels");
+    }
+    if (styleImages.length) {
+      throw new Error("ComfyUI styleImages are not supported yet; keep references inside the workflow");
+    }
+    if (spec.palette.length) {
+      throw new Error("ComfyUI does not map PixelKiln palette values yet; encode palette control in the workflow");
+    }
+    if (spec.seed != null && !options.bindings.seed) {
+      throw new Error("ComfyUI requires bindings.seed when the style declares a seed");
+    }
+    validateWorkflowBindings(options.workflow, options);
+  }
+  rateLimit() {
+    return { spacingMs: 0, maxInFlight: 1 };
+  }
+  async submit(spec, styleImages) {
+    this.validate(spec, styleImages);
+    const options = resolvedOptions(spec);
+    const workflow = structuredClone(options.workflow);
+    setBinding(workflow, options.bindings.prompt, spec.prompt);
+    setBinding(workflow, options.bindings.width, spec.width);
+    setBinding(workflow, options.bindings.height, spec.height);
+    setBinding(workflow, options.bindings.batchSize, options.numImages);
+    if (spec.seed != null && options.bindings.seed) {
+      setBinding(workflow, options.bindings.seed, spec.seed);
+    }
+    const promptId = await this.client.submit(workflow);
+    return { jobId: encodeJob(promptId, options.outputNodeId) };
+  }
+  async poll(jobId, _generator, context) {
+    const { promptId, outputNodeId } = decodeJob(jobId);
+    const history = await this.client.history(promptId);
+    const entry = historyEntry(history, promptId);
+    if (!entry) return { status: "processing" };
+    const status = isObject(entry.status) ? entry.status : {};
+    const statusText = typeof status.status_str === "string" ? status.status_str : "";
+    if (statusText === "error") {
+      return { status: "failed", error: historyError(status) };
+    }
+    if (status.completed === false) return { status: "processing" };
+    const images = outputImages(entry, outputNodeId);
+    if (images instanceof Error) return { status: "failed", error: images.message };
+    const expected = context?.spec ? resolvedOptions(context.spec).numImages : null;
+    if (expected != null && images.length !== expected) {
+      return {
+        status: "failed",
+        error: `ComfyUI output node "${outputNodeId}" returned ${images.length} image(s), expected ${expected}`
+      };
+    }
+    const metadata = context?.spec ? comfyMetadata(context.spec, promptId, outputNodeId, images) : {
+      promptId,
+      outputNodeId,
+      outputCount: images.length
+    };
+    if (images.length > 1) {
+      return {
+        status: "review",
+        candidateUrls: images.map((image) => this.client.viewUrl(image)),
+        metadata
+      };
+    }
+    const sourceUrl = sourceRef(images[0]);
+    return {
+      status: "ready",
+      objectId: `${promptId}#${outputNodeId}#0`,
+      sourceUrl,
+      sources: [{ url: sourceUrl, mediaType: MediaType.PNG }],
+      metadata
+    };
+  }
+  async selectCandidate(jobId, index) {
+    const { promptId, outputNodeId } = decodeJob(jobId);
+    const history = await this.client.history(promptId);
+    const entry = historyEntry(history, promptId);
+    if (!entry) throw new Error(`ComfyUI prompt ${promptId} is not complete`);
+    const images = outputImages(entry, outputNodeId);
+    if (images instanceof Error) throw images;
+    const image = images[index];
+    if (!image) throw new Error(`ComfyUI prompt ${promptId} has no candidate at index ${index}`);
+    return {
+      objectId: `${promptId}#${outputNodeId}#${index}`,
+      sourceUrl: sourceRef(image)
+    };
+  }
+  async download(url) {
+    return this.client.download(url);
+  }
+  async checkConnection() {
+    await this.client.checkConnection();
+  }
+};
+function parseOptions(value) {
+  const allowed = /* @__PURE__ */ new Set(["workflowFile", "outputNodeId", "numImages", "bindings", "workflow", "workflowSha256"]);
+  const extra = Object.keys(value).filter((key) => !allowed.has(key));
+  if (extra.length) throw new Error(`Unknown ComfyUI option(s): ${extra.join(", ")}`);
+  const workflowFile = requiredString(value.workflowFile, "workflowFile");
+  const outputNodeId = requiredString(value.outputNodeId, "outputNodeId");
+  const numImages = value.numImages ?? 1;
+  if (!Number.isInteger(numImages) || Number(numImages) < 1 || Number(numImages) > 16) {
+    throw new Error("ComfyUI numImages must be a whole number from 1 to 16");
+  }
+  if (!isObject(value.bindings)) throw new Error("ComfyUI bindings must be an object");
+  const bindingKeys = /* @__PURE__ */ new Set(["prompt", "width", "height", "batchSize", "seed"]);
+  const extraBindings = Object.keys(value.bindings).filter((key) => !bindingKeys.has(key));
+  if (extraBindings.length) throw new Error(`Unknown ComfyUI binding(s): ${extraBindings.join(", ")}`);
+  const bindings = {
+    prompt: parseBinding(value.bindings.prompt, "prompt"),
+    width: parseBinding(value.bindings.width, "width"),
+    height: parseBinding(value.bindings.height, "height"),
+    batchSize: parseBinding(value.bindings.batchSize, "batchSize"),
+    ...value.bindings.seed == null ? {} : { seed: parseBinding(value.bindings.seed, "seed") }
+  };
+  const workflow = value.workflow == null ? void 0 : parseWorkflow(value.workflow, workflowFile);
+  const workflowSha256 = value.workflowSha256 == null ? void 0 : requiredString(value.workflowSha256, "workflowSha256");
+  return {
+    workflowFile,
+    outputNodeId,
+    numImages: Number(numImages),
+    bindings,
+    ...workflow ? { workflow } : {},
+    ...workflowSha256 ? { workflowSha256 } : {}
+  };
+}
+function resolvedOptions(spec) {
+  const options = parseOptions(spec.providerOptions);
+  if (!options.workflow || !options.workflowSha256) {
+    throw new Error("ComfyUI workflow options were not resolved from workflowFile");
+  }
+  return options;
+}
+function parseBinding(value, name) {
+  if (!isObject(value)) throw new Error(`ComfyUI bindings.${name} must be an object`);
+  const extra = Object.keys(value).filter((key) => key !== "nodeId" && key !== "input");
+  if (extra.length) throw new Error(`Unknown ComfyUI bindings.${name} field(s): ${extra.join(", ")}`);
+  return {
+    nodeId: requiredString(value.nodeId, `bindings.${name}.nodeId`),
+    input: requiredString(value.input, `bindings.${name}.input`)
+  };
+}
+function parseWorkflow(value, label) {
+  if (!isObject(value) || !Object.keys(value).length) {
+    throw new Error(`ComfyUI workflow is not a non-empty API-format object: ${label}`);
+  }
+  for (const [nodeId, node] of Object.entries(value)) {
+    if (!isObject(node) || typeof node.class_type !== "string" || !isObject(node.inputs)) {
+      throw new Error(`ComfyUI workflow node "${nodeId}" must contain class_type and inputs`);
+    }
+  }
+  return value;
+}
+function validateWorkflowBindings(workflow, options) {
+  for (const [name, binding] of Object.entries(options.bindings)) {
+    if (!binding) continue;
+    const node = workflow[binding.nodeId];
+    if (!node) throw new Error(`ComfyUI ${name} binding refers to missing node "${binding.nodeId}"`);
+    if (!Object.hasOwn(node.inputs, binding.input)) {
+      throw new Error(
+        `ComfyUI ${name} binding refers to missing input "${binding.input}" on node "${binding.nodeId}"`
+      );
+    }
+  }
+  if (!workflow[options.outputNodeId]) {
+    throw new Error(`ComfyUI outputNodeId refers to missing node "${options.outputNodeId}"`);
+  }
+}
+function setBinding(workflow, binding, value) {
+  const node = workflow[binding.nodeId];
+  if (!node || !Object.hasOwn(node.inputs, binding.input)) {
+    throw new Error(`ComfyUI binding ${binding.nodeId}.${binding.input} is unavailable`);
+  }
+  node.inputs[binding.input] = value;
+}
+function historyEntry(history, promptId) {
+  if (!isObject(history)) throw new Error("ComfyUI returned invalid history JSON");
+  const entry = history[promptId];
+  if (entry == null) return null;
+  if (!isObject(entry)) throw new Error(`ComfyUI returned invalid history for prompt ${promptId}`);
+  return entry;
+}
+function outputImages(entry, outputNodeId) {
+  if (!isObject(entry.outputs)) return new Error("ComfyUI completed without workflow outputs");
+  const output = entry.outputs[outputNodeId];
+  if (!isObject(output) || !Array.isArray(output.images)) {
+    return new Error(`ComfyUI output node "${outputNodeId}" returned no images`);
+  }
+  const images = [];
+  for (const value of output.images) {
+    if (!isObject(value) || typeof value.filename !== "string" || typeof value.subfolder !== "string" || value.type !== "output") {
+      return new Error(`ComfyUI output node "${outputNodeId}" returned an invalid image record`);
+    }
+    images.push({ filename: value.filename, subfolder: value.subfolder, type: "output" });
+  }
+  if (!images.length) return new Error(`ComfyUI output node "${outputNodeId}" returned no images`);
+  return images;
+}
+function comfyMetadata(spec, promptId, outputNodeId, images) {
+  const options = resolvedOptions(spec);
+  return {
+    promptId,
+    outputNodeId,
+    outputCount: images.length,
+    workflowFile: options.workflowFile,
+    workflowSha256: options.workflowSha256,
+    files: images.map((image) => ({ ...image }))
+  };
+}
+function encodeJob(promptId, outputNodeId) {
+  return `${promptId}#${encodeURIComponent(outputNodeId)}`;
+}
+function decodeJob(jobId) {
+  const split = jobId.lastIndexOf("#");
+  if (split < 1 || split === jobId.length - 1) throw new Error(`Invalid ComfyUI job id "${jobId}"`);
+  return {
+    promptId: jobId.slice(0, split),
+    outputNodeId: decodeURIComponent(jobId.slice(split + 1))
+  };
+}
+function sourceRef(image) {
+  const url = new URL("comfyui://output");
+  url.searchParams.set("filename", image.filename);
+  url.searchParams.set("subfolder", image.subfolder);
+  url.searchParams.set("type", image.type);
+  return url.toString();
+}
+function parseSource(source) {
+  let url;
+  try {
+    url = new URL(source);
+  } catch {
+    throw new Error("Invalid ComfyUI output reference");
+  }
+  const filename = url.searchParams.get("filename");
+  const subfolder = url.searchParams.get("subfolder");
+  const type = url.searchParams.get("type");
+  if (url.protocol !== "comfyui:" || url.hostname !== "output" || !filename || subfolder == null || type !== "output") {
+    throw new Error("Invalid ComfyUI output reference");
+  }
+  return { filename, subfolder, type };
+}
+function normalizeBaseUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("COMFYUI_BASE_URL must be an absolute HTTP(S) URL");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("COMFYUI_BASE_URL must use HTTP or HTTPS");
+  }
+  url.hash = "";
+  url.search = "";
+  return url.toString().replace(/\/$/, "");
+}
+function historyError(status) {
+  const messages = Array.isArray(status.messages) ? status.messages : [];
+  for (const message2 of messages) {
+    if (!Array.isArray(message2) || message2[0] !== "execution_error" || !isObject(message2[1])) continue;
+    const detail = message2[1].exception_message;
+    if (typeof detail === "string" && detail.trim()) {
+      return `ComfyUI execution failed: ${detail.trim().slice(0, 300)}`;
+    }
+  }
+  return "ComfyUI execution failed";
+}
+function apiError(value) {
+  if (!isObject(value)) return null;
+  const raw = typeof value.error === "string" ? value.error : isObject(value.error) && typeof value.error.message === "string" ? value.error.message : typeof value.message === "string" ? value.message : null;
+  const nodes = isObject(value.node_errors) ? Object.keys(value.node_errors) : [];
+  if (nodes.length) {
+    return `${raw ? `${raw}; ` : ""}invalid workflow node(s): ${nodes.slice(0, 8).join(", ")}`;
+  }
+  return raw?.trim().slice(0, 300) || null;
+}
+function requiredString(value, name) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`ComfyUI ${name} must be a non-empty string`);
+  return value.trim();
+}
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (!isObject(value)) return value;
+  return Object.fromEntries(
+    Object.keys(value).sort().map((key) => [key, canonical(value[key])])
+  );
+}
+
+// src/providers/pixellab.ts
+import { mkdirSync, existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import os from "os";
+import path3 from "path";
+
+// src/client.ts
+import { z } from "zod";
+var BASE = process.env.PIXELLAB_API_BASE ?? "https://api.pixellab.ai/v2";
+var MAX_RETRIES = 4;
+var MAX_DOWNLOAD_BYTES = 64 * 1024 * 1024;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function shouldRetry(status) {
+  return status === 429 || status === 408 || status >= 500;
+}
+function backoffMs(attempt) {
+  const base = Math.min(1e3 * 2 ** attempt, 16e3);
+  return base + Math.floor(Math.random() * 400);
+}
+function retryAfterMs(value, now = Date.now()) {
+  if (!value) return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(value);
+  if (!Number.isFinite(date)) return null;
+  return Math.max(0, date - now);
+}
+var BalanceResponseSchema = z.object({
+  credits: z.object({ usd: z.number() }).passthrough(),
+  subscription: z.object({
+    generations: z.number(),
+    total: z.number(),
+    plan: z.string().nullable().optional()
+  }).passthrough()
+}).passthrough();
+var ObjectSubmitSchema = z.object({
+  background_job_id: z.string().min(1),
+  object_id: z.string().min(1),
+  status: z.string().default("queued"),
+  n_frames: z.number().int().min(0)
+}).passthrough();
+var MapSubmitSchema = z.object({
+  background_job_id: z.string().min(1),
+  object_id: z.string().min(1),
+  status: z.string().default("processing")
+}).passthrough();
+var TilesSubmitSchema = z.object({
+  tile_id: z.string().min(1),
+  background_job_id: z.string().min(1),
+  status: z.literal("processing").default("processing")
+}).passthrough();
+var TilesProSchema = z.object({
+  storage_urls: z.record(z.string()),
+  kind: z.string().nullable().default(null),
+  tile_rules: z.record(z.unknown()).nullable().optional()
+}).passthrough();
+var PixelLabObjectSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().nullable().default(null),
+  prompt: z.string().default(""),
+  size: z.object({ width: z.number().int().positive(), height: z.number().int().positive() }),
+  directions: z.number().default(0),
+  created_at: z.string(),
+  view: z.string().nullable().default(null),
+  preview_url: z.string().nullable().optional(),
+  rotation_urls: z.record(z.string().nullable()).nullable().optional(),
+  frame_urls: z.array(z.string()).nullable().optional(),
+  tags: z.array(z.string()).default([]),
+  status: z.string().nullable().default(null),
+  progress_percent: z.number().nullable().optional(),
+  eta_seconds: z.number().nullable().optional()
+}).passthrough();
+var MapObjectSchema = z.object({
+  object_id: z.string().min(1),
+  status: z.string(),
+  description: z.string().nullable().default(null),
+  width: z.number().nullable().default(null),
+  height: z.number().nullable().default(null),
+  download_url: z.string().nullable().default(null)
+}).passthrough();
+var ObjectListSchema = z.object({ objects: z.array(PixelLabObjectSchema), total: z.number().int().min(0) }).passthrough();
+var PixfluxResponseSchema = z.object({ image: z.object({ base64: z.string().min(1) }).passthrough(), usage: z.unknown().optional() }).passthrough();
+var SelectFramesSchema = z.object({ created_object_ids: z.array(z.string()) }).passthrough();
+function validateResponse(schema, raw, operation) {
+  const parsed = schema.safeParse(raw);
+  if (parsed.success) return parsed.data;
+  const issues = parsed.error.issues.slice(0, 4).map((i) => `${i.path.join(".") || "response"}: ${i.message}`).join("; ");
+  throw new Error(`Invalid PixelLab response for ${operation}: ${issues}`);
+}
+var PixelLabError = class extends Error {
+  constructor(message2, status, body) {
+    super(message2);
+    this.status = status;
+    this.body = body;
+    this.name = "PixelLabError";
+  }
+  status;
+  body;
+};
+var PixelLabClient = class {
+  constructor(apiKey, timeoutMs = 12e4) {
+    this.apiKey = apiKey;
+    this.timeoutMs = timeoutMs;
+    if (!apiKey) throw new Error("PIXELLAB_API_KEY is required");
+  }
+  apiKey;
+  timeoutMs;
+  /**
+   * Retries only what is safe to retry: transport failures, 429, and 5xx.
+   * A 4xx other than 429 is a bad request and retrying it just wastes time.
+   *
+   * POSTs that create objects are included, which is a deliberate trade: the
+   * failure mode of not retrying (a dropped asset in a 65-item run) is more
+   * common than the failure mode of retrying (a duplicate object), and a
+   * duplicate is visible and free to delete whereas a silent gap is neither.
+   */
+  async request(path20, init, attempt = 0) {
+    const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
+    let res;
+    try {
+      res = await fetch(`${BASE}${path20}`, {
+        ...init,
+        signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
+        headers: {
+          Authorization: auth,
+          "Content-Type": "application/json",
+          ...init?.headers ?? {}
+        }
+      });
+    } catch (err) {
+      if (attempt < MAX_RETRIES) {
+        await sleep(backoffMs(attempt));
+        return this.request(path20, init, attempt + 1);
+      }
+      throw err;
+    }
+    if (!res.ok && shouldRetry(res.status) && attempt < MAX_RETRIES) {
+      const waitMs = retryAfterMs(res.headers.get("retry-after")) ?? backoffMs(attempt);
+      await sleep(waitMs);
+      return this.request(path20, init, attempt + 1);
+    }
+    const text = await res.text();
+    if (!res.ok) {
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path20} \u2192 ${res.status}`, res.status, text);
+    }
+    if (!text) return {};
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new Error(`${init?.method ?? "GET"} ${path20} returned invalid JSON`);
+    }
+  }
+  async balance() {
+    const raw = validateResponse(BalanceResponseSchema, await this.request("/balance"), "balance");
+    return {
+      usd: raw.credits?.usd ?? 0,
+      generations: raw.subscription?.generations ?? 0,
+      total: raw.subscription?.total ?? 0,
+      plan: raw.subscription?.plan ?? "unknown"
+    };
+  }
+  /**
+   * Square objects that persist indefinitely.
+   *
+   * `size` and `styleImages` are mutually exclusive at the API level: when style
+   * images are supplied the largest one dictates the output size. So style
+   * references must already be at the target resolution — a 128px reference
+   * silently produces 128px output and a different candidate count.
+   */
+  async create1Direction(args) {
+    const body = { description: args.description };
+    if (args.styleImages?.length) {
+      body.style_images = args.styleImages.map(({ base64, format }) => ({
+        type: "base64",
+        base64,
+        format
+      }));
+    } else if (args.size != null) {
+      body.size = args.size;
+    }
+    if (args.view) body.view = args.view;
+    if (args.itemDescriptions?.length) body.item_descriptions = args.itemDescriptions;
+    const raw = await this.request("/create-1-direction-object", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    const parsed = validateResponse(ObjectSubmitSchema, raw, "create-1-direction-object");
+    return parsed;
+  }
+  /**
+   * Arbitrary width x height. Returns a single result — no selection step.
+   *
+   * These AUTO-DELETE AFTER 8 HOURS, so `fetch` must run in the same session as
+   * `submit`. The pipeline warns when a map-object entry is older than that.
+   */
+  async createMapObject(args) {
+    const body = {
+      description: args.description,
+      image_size: { width: args.width, height: args.height }
+    };
+    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(
+      MapSubmitSchema,
+      await this.request("/map-objects", { method: "POST", body: JSON.stringify(body) }),
+      "create map object"
+    );
+  }
+  /**
+   * Draws a whole tile set in one call — many variations, or a connectable
+   * set when `tileFeature` is given.
+   *
+   * `styleImages` here is NOT the shape `create-1-direction-object` uses.
+   * TilesProStyleImage is flat — `{base64, width, height}`, all three
+   * required — where 1dir wants `{type, base64, format}`. Confirmed against
+   * the OpenAPI schema; sending 1dir's shape is rejected as an extra field.
+   *
+   * Passing style images also makes the API ignore `tileType` and `tileView`
+   * and copy the reference's tile geometry instead.
+   */
+  async createTilesPro(args) {
+    const body = { description: args.description };
+    if (args.tileSize != null) body.tile_size = args.tileSize;
+    if (args.tileType) body.tile_type = args.tileType;
+    if (args.tileView) body.tile_view = args.tileView;
+    if (args.tileFeature) body.tile_feature = args.tileFeature;
+    if (args.outlineMode) body.outline_mode = args.outlineMode;
+    if (args.seed != null) body.seed = args.seed;
+    if (args.styleImages?.length) body.style_images = args.styleImages;
+    return validateResponse(
+      TilesSubmitSchema,
+      await this.request("/create-tiles-pro", { method: "POST", body: JSON.stringify(body) }),
+      "create tiles"
+    );
+  }
+  /** Throws PixelLabError(423) while the set is still drawing — see TilesPro. */
+  async getTilesPro(tileId) {
+    return validateResponse(
+      TilesProSchema,
+      await this.request(`/tiles-pro/${tileId}`),
+      "get tiles"
+    );
+  }
+  /**
+   * Synchronous single-image generation. Returns the PNG inline rather than a
+   * job id, and is the only endpoint that honours a forced palette —
+   * `color_image` on /map-objects returns a 500 whatever the payload shape.
+   */
+  async createImagePixflux(args) {
+    const body = {
+      description: args.description,
+      image_size: { width: args.width, height: args.height },
+      no_background: args.noBackground ?? true
+    };
+    if (args.paletteSwatchBase64) {
+      body.color_image = { type: "base64", base64: args.paletteSwatchBase64, format: "png" };
+    }
+    if (args.seed != null) body.seed = args.seed;
+    const res = validateResponse(
+      PixfluxResponseSchema,
+      await this.request("/create-image-pixflux", {
+        method: "POST",
+        body: JSON.stringify(body)
+      }),
+      "create pixflux image"
+    );
+    const b64 = res.image.base64;
+    return { png: Buffer.from(b64, "base64"), usage: res.usage };
+  }
+  async getObject(objectId) {
+    return validateResponse(
+      PixelLabObjectSchema,
+      await this.request(`/objects/${objectId}`),
+      "get object"
+    );
+  }
+  async getMapObject(objectId) {
+    return validateResponse(
+      MapObjectSchema,
+      await this.request(`/map-objects/${objectId}`),
+      "get map object"
+    );
+  }
+  async listObjects(limit = 50, offset = 0) {
+    return validateResponse(
+      ObjectListSchema,
+      await this.request(`/objects?limit=${limit}&offset=${offset}`),
+      "list objects"
+    );
+  }
+  /** Walks the whole account. Used by `adopt` to reconcile orphaned objects. */
+  async *iterateObjects(pageSize = 100) {
+    let offset = 0;
+    for (; ; ) {
+      const page = await this.listObjects(pageSize, offset);
+      for (const obj of page.objects) yield obj;
+      offset += page.objects.length;
+      if (page.objects.length === 0 || offset >= page.total) return;
+    }
+  }
+  /**
+   * Promotes chosen candidates to standalone objects, each with its own id.
+   * The review parent survives until nothing is left in it, so the returned
+   * `created_object_ids` — not the parent id — is what should be recorded.
+   */
+  async selectFrames(objectId, indices, commonTag) {
+    const raw = await this.request(`/objects/${objectId}/select-frames`, {
+      method: "POST",
+      body: JSON.stringify(commonTag ? { indices, common_tag: commonTag } : { indices })
+    });
+    return validateResponse(SelectFramesSchema, raw, "select frames");
+  }
+  /** Irreversible. Only reached via `purge`, behind an explicit confirmation. */
+  deleteObject(objectId) {
+    return this.request(`/objects/${objectId}`, { method: "DELETE" });
   }
-  const ihdr = Buffer.alloc(13);
-  ihdr.writeUInt32BE(width, 0);
-  ihdr.writeUInt32BE(height, 4);
-  ihdr[8] = 8;
-  ihdr[9] = 2;
-  return Buffer.concat([
-    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
-    chunk("IHDR", ihdr),
-    chunk("IDAT", deflateSync(raw)),
-    chunk("IEND", Buffer.alloc(0))
-  ]);
-}
-function encodeRgbaPng(width, height, rgba) {
-  if (rgba.length !== width * height * 4) {
-    throw new Error(`expected ${width * height * 4} bytes of RGBA, got ${rgba.length}`);
+  dismissReview(objectId) {
+    return this.request(`/objects/${objectId}/dismiss-review`, { method: "POST" });
   }
-  const stride = width * 4;
-  const raw = Buffer.alloc((stride + 1) * height);
-  for (let y = 0; y < height; y++) {
-    raw[y * (stride + 1)] = 0;
-    rgba.copy(raw, y * (stride + 1) + 1, y * stride, (y + 1) * stride);
+  /** Free and synchronous. Replaces the full tag set — include tags you want to keep. */
+  setTags(objectId, tags) {
+    return this.request(`/objects/${objectId}/tags`, { method: "PATCH", body: JSON.stringify({ tags }) });
   }
-  const ihdr = Buffer.alloc(13);
-  ihdr.writeUInt32BE(width, 0);
-  ihdr.writeUInt32BE(height, 4);
-  ihdr[8] = 8;
-  ihdr[9] = 6;
-  return Buffer.concat([
-    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
-    chunk("IHDR", ihdr),
-    chunk("IDAT", deflateSync(raw)),
-    chunk("IEND", Buffer.alloc(0))
-  ]);
-}
-function paletteSwatch(hexes, size = 64) {
-  const colours = hexes.map(parseHex);
-  if (!colours.length) throw new Error("palette is empty");
-  const rgb = Buffer.alloc(size * size * 3);
-  const band = Math.max(1, Math.floor(size / colours.length));
-  for (let y = 0; y < size; y++) {
-    for (let x = 0; x < size; x++) {
-      const c = colours[Math.min(colours.length - 1, Math.floor(x / band))];
-      const o = (y * size + x) * 3;
-      rgb[o] = c.r;
-      rgb[o + 1] = c.g;
-      rgb[o + 2] = c.b;
+  /** Storage URLs are public; no auth header, and sending one can break the CDN request. */
+  async download(url) {
+    const res = await fetch(url, { signal: AbortSignal.timeout(this.timeoutMs) });
+    if (!res.ok) throw new PixelLabError(`download ${url} \u2192 ${res.status}`, res.status, "");
+    const declared = Number(res.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > MAX_DOWNLOAD_BYTES) {
+      throw new Error(`download ${url} exceeds the ${MAX_DOWNLOAD_BYTES}-byte safety limit`);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    if (buf.length > MAX_DOWNLOAD_BYTES) {
+      throw new Error(`download ${url} exceeds the ${MAX_DOWNLOAD_BYTES}-byte safety limit`);
     }
+    return buf;
   }
-  return encodeRgbPng(size, size, rgb);
-}
-function parseHex(hex2) {
-  const m = /^#?([0-9a-f]{6})$/i.exec(hex2.trim());
-  if (!m) throw new Error(`invalid hex colour "${hex2}" \u2014 expected #rrggbb`);
-  const n = parseInt(m[1], 16);
-  return { r: n >> 16 & 255, g: n >> 8 & 255, b: n & 255 };
+};
+function clientFromEnv() {
+  const key = process.env.PIXELLAB_API_KEY;
+  if (!key) {
+    throw new Error(
+      "PIXELLAB_API_KEY is not set.\nLooked in the environment, and in .env.local / .env beside the manifest and in the current directory."
+    );
+  }
+  return new PixelLabClient(key);
 }
 
 // src/types.ts
@@ -853,8 +1400,8 @@ var StyleSchema = z2.object({
   // `map` is the default because it is 20-40x cheaper and correct for any
   // asset that is not going to be rotated or animated.
   generator: GeneratorSchema.default("map"),
-  /** Square edge length for `1dir`. 32-256. */
-  size: z2.number().int().min(32).max(256).optional(),
+  /** Square edge length. The active provider owns its exact limit. */
+  size: z2.number().int().min(16).max(8192).optional(),
   view: z2.string().optional(),
   /** Appended to every asset prompt in this style. Where the look is defined. */
   promptSuffix: z2.string().default(""),
@@ -970,8 +1517,8 @@ var AssetSchema = z2.object({
   /** Subdirectory under the style's outDir. Optional. */
   category: z2.string().optional(),
   /** Overrides the style default. `map` generator only. */
-  width: z2.number().int().min(16).max(400).optional(),
-  height: z2.number().int().min(16).max(400).optional(),
+  width: z2.number().int().min(16).max(8192).optional(),
+  height: z2.number().int().min(16).max(8192).optional(),
   /** Overrides the style default. `1dir` generator only. */
   size: z2.number().int().min(32).max(256).optional(),
   /** Explicit output path relative to outDir. Media-aware providers may replace its extension. */
@@ -1152,7 +1699,7 @@ var PixelLabProvider = class _PixelLabProvider {
    * filename, polling is an existence check, and downloading is a file read.
    */
   static cacheDir() {
-    const dir = path2.join(os.tmpdir(), "pixelkiln-pixflux");
+    const dir = path3.join(os.tmpdir(), "pixelkiln-pixflux");
     mkdirSync(dir, { recursive: true });
     return dir;
   }
@@ -1167,6 +1714,12 @@ var PixelLabProvider = class _PixelLabProvider {
     };
   }
   validate(spec, styleImages) {
+    if (spec.generator === "1dir" && (spec.width < 32 || spec.width > 256)) {
+      throw new Error("PixelLab 1dir dimensions must be between 32 and 256 pixels");
+    }
+    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 === "map") {
       requirePixelLabOption("view", spec.view, ["low top-down", "high top-down", "side"]);
       requirePixelLabOption("outline", spec.outline, [
@@ -1214,8 +1767,8 @@ var PixelLabProvider = class _PixelLabProvider {
         paletteSwatchBase64: swatch,
         seed: spec.seed
       });
-      const jobId = randomUUID();
-      writeFileSync(path2.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), png);
+      const jobId = randomUUID2();
+      writeFileSync(path3.join(_PixelLabProvider.cacheDir(), `${jobId}.png`), png);
       return { jobId };
     }
     if (spec.generator === "tiles") {
@@ -1256,7 +1809,7 @@ var PixelLabProvider = class _PixelLabProvider {
   }
   async poll(jobId, generator, context) {
     if (generator === "pixflux") {
-      const file = path2.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
+      const file = path3.join(_PixelLabProvider.cacheDir(), `${jobId}.png`);
       if (existsSync2(file)) {
         const sourceUrl = `file://${file}`;
         return { status: "ready", objectId: jobId, sourceUrl, sources: [{ url: sourceUrl }] };
@@ -1402,95 +1955,10 @@ function firstUrl(urls) {
   return Object.values(urls).find((u) => typeof u === "string") ?? null;
 }
 
-// src/media.ts
-var MediaType = {
-  PNG: "image/png",
-  GIF: "image/gif"
-};
-var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
-function mediaExtension(mediaType) {
-  return mediaType === MediaType.GIF ? ".gif" : ".png";
-}
-function mediaTypeFromExtension(file) {
-  const lower = file.toLowerCase();
-  if (lower.endsWith(".png")) return MediaType.PNG;
-  if (lower.endsWith(".gif")) return MediaType.GIF;
-  return null;
-}
-function detectMediaType(bytes) {
-  if (bytes.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) return MediaType.PNG;
-  const header = bytes.subarray(0, 6).toString("ascii");
-  if (header === "GIF87a" || header === "GIF89a") return MediaType.GIF;
-  return null;
-}
-function validateMedia(bytes, expected) {
-  const actual = detectMediaType(bytes);
-  if (!actual) throw new Error(`response was not a supported PNG or GIF (${bytes.length} bytes)`);
-  if (expected && actual !== expected) {
-    throw new Error(`response was ${actual}, expected ${expected}`);
-  }
-  if (actual === MediaType.PNG) {
-    decodePng(bytes);
-  } else {
-    validateGif(bytes);
-  }
-  return actual;
-}
-function validateGif(bytes) {
-  if (bytes.length < 14) throw new Error("invalid GIF: truncated logical screen descriptor");
-  const width = bytes.readUInt16LE(6);
-  const height = bytes.readUInt16LE(8);
-  if (!width || !height) throw new Error("invalid GIF: zero-sized logical screen");
-  const packed = bytes[10];
-  let offset = 13;
-  if (packed & 128) offset += 3 * 2 ** ((packed & 7) + 1);
-  if (offset > bytes.length) throw new Error("invalid GIF: truncated global color table");
-  let sawImage = false;
-  while (offset < bytes.length) {
-    const marker = bytes[offset];
-    if (marker === 59) {
-      if (!sawImage) throw new Error("invalid GIF: contains no image frame");
-      return;
-    }
-    if (marker === 44) {
-      if (offset + 10 > bytes.length) throw new Error("invalid GIF: truncated image descriptor");
-      const imagePacked = bytes[offset + 9];
-      offset += 10;
-      if (imagePacked & 128) offset += 3 * 2 ** ((imagePacked & 7) + 1);
-      if (offset >= bytes.length) throw new Error("invalid GIF: missing image data");
-      offset++;
-      offset = skipSubBlocks(bytes, offset);
-      sawImage = true;
-      continue;
-    }
-    if (marker === 33) {
-      if (offset + 2 > bytes.length) throw new Error("invalid GIF: truncated extension");
-      offset = skipSubBlocks(bytes, offset + 2);
-      continue;
-    }
-    throw new Error(`invalid GIF: unexpected block marker 0x${marker.toString(16)}`);
-  }
-  throw new Error("invalid GIF: missing trailer");
-}
-function skipSubBlocks(bytes, start) {
-  let offset = start;
-  for (; ; ) {
-    if (offset >= bytes.length) throw new Error("invalid GIF: truncated data blocks");
-    const size = bytes[offset];
-    offset++;
-    if (size === 0) return offset;
-    offset += size;
-    if (offset > bytes.length) throw new Error("invalid GIF: truncated data block");
-  }
-}
-function cacheFileName(hash, mediaType = MediaType.PNG) {
-  return `${hash}${mediaExtension(mediaType)}`;
-}
-
 // src/providers/retrodiffusion.ts
-var DEFAULT_BASE_URL = "https://api.retrodiffusion.ai/v1";
+var DEFAULT_BASE_URL2 = "https://api.retrodiffusion.ai/v1";
 var RetroDiffusionClient = class {
-  constructor(token, baseUrl = DEFAULT_BASE_URL, request = fetch) {
+  constructor(token, baseUrl = DEFAULT_BASE_URL2, request = fetch) {
     this.token = token;
     this.baseUrl = baseUrl;
     this.request = request;
@@ -1528,9 +1996,9 @@ var RetroDiffusionClient = class {
     }
     return balance;
   }
-  async call(path19, init = {}) {
+  async call(path20, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path19}`, {
+    const response = await this.request(`${this.baseUrl}${path20}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -1837,56 +2305,23 @@ registerProvider({
     return RetroDiffusionProvider.forOffline();
   }
 });
+registerProvider({
+  id: "comfyui",
+  create(mode2) {
+    if (mode2 === "online") return ComfyUIProvider.fromEnv();
+    if (mode2 === "downloads") return ComfyUIProvider.forDownloads();
+    return ComfyUIProvider.forOffline();
+  }
+});
 
 // src/manifest.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path3 from "path";
-
-// src/hash.ts
-import { createHash } from "crypto";
-import { readFile } from "fs/promises";
-function sha256(data) {
-  return createHash("sha256").update(data).digest("hex");
-}
-async function sha256File(path19) {
-  return sha256(await readFile(path19));
-}
-function specHash(spec, styleImageHashes) {
-  return sha256(
-    JSON.stringify({
-      // Preserve every existing PixelLab hash while making a provider switch
-      // invalidate the spec. Older manifests implicitly mean pixellab.
-      provider: spec.provider === "pixellab" ? void 0 : spec.provider,
-      providerOptions: Object.keys(spec.providerOptions).length > 0 ? spec.providerOptions : void 0,
-      generator: spec.generator,
-      prompt: spec.prompt,
-      width: spec.width,
-      height: spec.height,
-      view: spec.view,
-      outline: spec.outline ?? null,
-      shading: spec.shading ?? null,
-      detail: spec.detail ?? null,
-      seed: spec.seed ?? null,
-      palette: spec.palette,
-      // `noBackground` only reaches the wire for pixflux; the tile fields are
-      // undefined for every other generator. `tileSize` is intentionally
-      // absent — width/height are derived from it, so it is already covered.
-      noBackground: spec.generator === "pixflux" || spec.provider !== "pixellab" ? spec.noBackground : void 0,
-      tileType: spec.tileType,
-      tileView: spec.tileView,
-      tileFeature: spec.tileFeature,
-      outlineMode: spec.outlineMode,
-      styleImages: styleImageHashes
-    })
-  );
-}
-
-// src/manifest.ts
+import path4 from "path";
 async function loadManifest(manifestPath) {
-  const abs = path3.resolve(manifestPath);
+  const abs = path4.resolve(manifestPath);
   if (!existsSync3(abs)) throw new Error(`No manifest at ${abs}`);
-  const parsed = ManifestSchema.safeParse(JSON.parse(await readFile2(abs, "utf8")));
+  const parsed = ManifestSchema.safeParse(JSON.parse(await readFile3(abs, "utf8")));
   if (!parsed.success) {
     const issues = parsed.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
     throw new Error(`Manifest at ${abs} is invalid:
@@ -1908,7 +2343,7 @@ ${issues}`);
     throw new Error(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
-  return { manifest: parsed.data, root: path3.dirname(abs), path: abs };
+  return { manifest: parsed.data, root: path4.dirname(abs), path: abs };
 }
 async function resolveSpecs(loaded, filter) {
   const { manifest, root } = loaded;
@@ -1931,11 +2366,11 @@ async function resolveSpecs(loaded, filter) {
   }
   const styleImageCache = /* @__PURE__ */ new Map();
   async function loadStyleImage(rel) {
-    const abs = path3.resolve(root, rel);
+    const abs = path4.resolve(root, rel);
     let hit = styleImageCache.get(abs);
     if (!hit) {
       if (!existsSync3(abs)) throw new Error(`Style image not found: ${abs}`);
-      const buf = await readFile2(abs);
+      const buf = await readFile3(abs);
       const metadata = imageMetadata(buf);
       if (!metadata) throw new Error(`Style image is not a readable PNG or JPEG: ${abs}`);
       if (metadata.width < 1 || metadata.height < 1) {
@@ -1948,6 +2383,10 @@ async function resolveSpecs(loaded, filter) {
   }
   for (const styleId of styleIds) {
     const style = manifest.styles[styleId];
+    const rawProviderOptions = style.providerOptions[activeProvider.id] ?? {};
+    const optionResolution = activeProvider.resolveOptions ? await activeProvider.resolveOptions(rawProviderOptions, { root, styleId }) : { options: rawProviderOptions };
+    const providerOptions = optionResolution.options;
+    const providerOptionIdentity = optionResolution.identity ?? providerOptions;
     const styleImageHashes = [];
     const styleImageDimensions = [];
     for (const img of style.styleImages) {
@@ -1980,15 +2419,15 @@ async function resolveSpecs(loaded, filter) {
       }
       const subject = asset.promptByStyle[styleId] ?? asset.prompt;
       const prompt = [style.promptPrefix, subject, style.promptSuffix].map((p) => p.trim()).filter(Boolean).join(", ");
-      const relFile = asset.file ?? path3.join(asset.category ?? "", `${assetId}.png`);
-      const outFile = path3.resolve(root, style.outDir, relFile);
+      const relFile = asset.file ?? path4.join(asset.category ?? "", `${assetId}.png`);
+      const outFile = path4.resolve(root, style.outDir, relFile);
       const tileSize = generator === "tiles" ? size : style.tileSize ?? 32;
       const tileVariations = tileFeatureOutputCount(generator === "tiles" ? style.tileFeature : void 0) ?? tileVariationCount(countNumberedDescriptions(prompt));
       const base = {
         styleId,
         assetId,
         provider: activeProvider.id,
-        providerOptions: style.providerOptions[activeProvider.id] ?? {},
+        providerOptions,
         generator,
         prompt,
         width,
@@ -2026,10 +2465,10 @@ async function resolveSpecs(loaded, filter) {
         outFile,
         tags,
         source: asset.source,
-        specHash: specHash(base, styleImageHashes)
+        specHash: specHash(base, styleImageHashes, providerOptionIdentity)
       };
       const resolvedImages = style.styleImages.map((image) => {
-        const hit = styleImageCache.get(path3.resolve(root, image.path));
+        const hit = styleImageCache.get(path4.resolve(root, image.path));
         return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
       });
       activeProvider.validate?.(resolved, resolvedImages);
@@ -2056,8 +2495,8 @@ async function resolveStyleImages(loaded, styleId) {
   if (!style) throw new Error(`Unknown style "${styleId}"`);
   const out = [];
   for (const img of style.styleImages) {
-    const file = path3.resolve(loaded.root, img.path);
-    const buf = await readFile2(file);
+    const file = path4.resolve(loaded.root, img.path);
+    const buf = await readFile3(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) {
@@ -2098,19 +2537,19 @@ function imageMetadata(buf) {
 
 // src/pipeline/pack.ts
 import { readFileSync as readFileSync3 } from "fs";
-import path6 from "path";
+import path7 from "path";
 
 // src/outputs.ts
-import path5 from "path";
+import path6 from "path";
 
 // src/lock.ts
-import { readFile as readFile3, writeFile, rename, mkdir, rmdir, rm, stat } from "fs/promises";
+import { readFile as readFile4, writeFile, rename, mkdir, rmdir, rm, stat } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path4 from "path";
+import path5 from "path";
 async function loadLock(lockPath) {
   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 Error(
       `Lockfile at ${lockPath} is malformed:
@@ -2122,7 +2561,7 @@ var saveQueues = /* @__PURE__ */ new Map();
 var dirtyPatches = /* @__PURE__ */ new WeakMap();
 var dirtyDeletes = /* @__PURE__ */ new WeakMap();
 function saveLock(lockPath, lock) {
-  const queueKey = path4.resolve(lockPath);
+  const queueKey = path5.resolve(lockPath);
   const previous = saveQueues.get(queueKey) ?? Promise.resolve();
   const next = previous.catch(() => {
   }).then(() => writeLockNow(lockPath, lock));
@@ -2134,7 +2573,7 @@ function saveLock(lockPath, lock) {
   return next;
 }
 async function writeLockNow(lockPath, lock) {
-  await mkdir(path4.dirname(path4.resolve(lockPath)), { recursive: true });
+  await mkdir(path5.dirname(path5.resolve(lockPath)), { recursive: true });
   const release = await acquireFileLock(lockPath);
   try {
     await writeLockWhileHeld(lockPath, lock);
@@ -2146,7 +2585,7 @@ async function writeLockWhileHeld(file, lock) {
   let disk = { version: 2, entries: {} };
   if (existsSync4(file)) {
     try {
-      disk = parseLock(JSON.parse(await readFile3(file, "utf8")));
+      disk = parseLock(JSON.parse(await readFile4(file, "utf8")));
     } catch (err) {
       throw new Error(
         `Refusing to overwrite malformed lockfile at ${file}: ${err instanceof Error ? err.message : String(err)}`
@@ -2275,19 +2714,19 @@ function spendByUnit(lock) {
 
 // src/outputs.ts
 function portableOutputPath(file, manifestDir) {
-  const root = path5.resolve(manifestDir);
-  const absolute = path5.isAbsolute(file) ? path5.normalize(file) : path5.resolve(root, file);
-  const relative = path5.relative(root, absolute);
-  const value = path5.isAbsolute(relative) ? absolute : relative;
-  return value.split(path5.sep).join("/");
+  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("/");
 }
 function resolveOutputPath(recordedPath, manifestDir) {
-  if (path5.isAbsolute(recordedPath)) return path5.normalize(recordedPath);
-  if (path5.win32.isAbsolute(recordedPath)) return recordedPath;
-  return path5.resolve(manifestDir, recordedPath.split(/[\\/]/).join(path5.sep));
+  if (path6.isAbsolute(recordedPath)) return path6.normalize(recordedPath);
+  if (path6.win32.isAbsolute(recordedPath)) return recordedPath;
+  return path6.resolve(manifestDir, recordedPath.split(/[\\/]/).join(path6.sep));
 }
 function expectedOutputPath(spec, role, index, total, mediaType) {
-  const originalExt = path5.extname(spec.outFile);
+  const originalExt = path6.extname(spec.outFile);
   const ext = mediaType ? mediaExtension(mediaType) : originalExt || ".png";
   const stem = originalExt ? spec.outFile.slice(0, -originalExt.length) : spec.outFile;
   if (total === 1) return `${stem}${ext}`;
@@ -2370,7 +2809,7 @@ function resolveSpecOutputs(spec, lock, manifestDir) {
     id: spec.assetId,
     index: 0,
     path: spec.outFile,
-    absolutePath: path5.resolve(spec.outFile),
+    absolutePath: path6.resolve(spec.outFile),
     sha256: ""
   }];
 }
@@ -2380,13 +2819,13 @@ function resolvePackInputs(raw, inputsFilePath) {
   if (!Array.isArray(raw) || !raw.length) {
     throw new Error("--inputs must be a non-empty JSON array of { id, path }");
   }
-  const baseDir = path6.dirname(path6.resolve(inputsFilePath));
+  const baseDir = path7.dirname(path7.resolve(inputsFilePath));
   return raw.map((entry, i) => {
     const e = entry;
     if (typeof e.id !== "string" || typeof e.path !== "string") {
       throw new Error(`--inputs[${i}] needs string "id" and "path"`);
     }
-    return { id: e.id, path: path6.resolve(baseDir, e.path) };
+    return { id: e.id, path: path7.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -2583,7 +3022,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     const cell = cells[id];
     const source = sources[id];
     if (source) {
-      placements.push({ id, path: path6.resolve(manifestDir, source), cell });
+      placements.push({ id, path: path7.resolve(manifestDir, source), cell });
       continue;
     }
     const entry = lock.entries[`${styleId}/${id}`];
@@ -2607,7 +3046,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
       `Nothing to mount for style "${styleId}": ${ids.length} asset(s) declare a cell, but none has generated output or a \`source\`. Run \`pixelkiln gen --style ${styleId}\`, or point each at a file.${detail}`
     );
   }
-  const basePng = mount.base ? readFileSync3(path6.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? readFileSync3(path7.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -2617,7 +3056,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: path6.resolve(manifestDir, mount.base),
+      path: path7.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -2628,7 +3067,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
 
 // src/pipeline/plan.ts
 import { existsSync as existsSync5 } from "fs";
-import path7 from "path";
+import path8 from "path";
 async function anyOutputModified(entry, spec) {
   for (let index = 0; index < entry.outputs.length; index++) {
     const output = entry.outputs[index];
@@ -2647,7 +3086,7 @@ async function buildPlan(specs, lock, opts = {}) {
       state = "missing";
       reason = "--force";
     } else if (!entry && spec.source) {
-      if (existsSync5(path7.resolve(spec.root, spec.source))) {
+      if (existsSync5(path8.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -2859,7 +3298,11 @@ async function poll(provider, lock, lockPath, opts = {}) {
           spec: currentSpec
         });
         if (state.status === "review") {
-          upsert(lock, key, { status: "review", reviewObjectId: entry.jobId });
+          upsert(lock, key, {
+            status: "review",
+            reviewObjectId: entry.jobId,
+            providerMetadata: state.metadata ? { ...entry.providerMetadata, [provider.id]: state.metadata } : entry.providerMetadata
+          });
           result.review++;
           log2(`  review  ${key} (${state.candidateUrls.length} candidates)`);
         } else if (state.status === "ready") {
@@ -2892,15 +3335,15 @@ async function poll(provider, lock, lockPath, opts = {}) {
 
 // src/pipeline/fetch.ts
 import { existsSync as existsSync6 } from "fs";
-import { mkdir as mkdir2, readFile as readFile4, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import path8 from "path";
+import { mkdir as mkdir2, readFile as readFile5, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import path9 from "path";
 async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   const log2 = opts.onProgress ?? (() => {
   });
   const result = { downloaded: 0, skipped: 0, failed: 0 };
   const specByKey = new Map(specs.map((s) => [lockKey(s.styleId, s.assetId), s]));
   normalizeLockOutputPaths(lock, specs);
-  const cacheDir = opts.cacheDir === false ? null : path8.resolve(opts.cacheDir ?? path8.join(path8.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : path9.resolve(opts.cacheDir ?? path9.join(path9.dirname(lockPath), ".pixelkiln", "cache"));
   const pending = Object.entries(lock.entries).filter(([key, e]) => {
     if (e.status === "selected" || e.status === "download-failed") return true;
     if (!opts.repair || e.status !== "downloaded") return false;
@@ -2952,7 +3395,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             if (cacheDir) {
               await cacheMedia(
                 cacheDir,
-                await readFile4(target),
+                await readFile5(target),
                 recorded.mediaType ?? MediaType.PNG,
                 recorded.sha256
               );
@@ -2963,7 +3406,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           const expectedMediaType = source.mediaType ?? recorded?.mediaType ?? MediaType.PNG;
           let buf = recorded && cacheDir ? await readCachedMedia(cacheDir, recorded.sha256, expectedMediaType) : null;
           if (buf) {
-            log2(`  cached  ${path8.relative(process.cwd(), target)}`);
+            log2(`  cached  ${path9.relative(process.cwd(), target)}`);
           } else {
             if (!source.url) {
               throw new Error(`no source URL or cached bytes remain for ${source.role ?? "asset"}`);
@@ -2981,7 +3424,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             );
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await mkdir2(path8.dirname(target), { recursive: true });
+          await mkdir2(path9.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
           await writeFile2(tmp, buf);
           outputs.push({
@@ -2993,7 +3436,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           upsert(lock, key, { outputs: mergeOutputs(entry.outputs, outputs) });
           await saveLock(lockPath, lock);
           await rename2(tmp, target);
-          log2(`  wrote   ${path8.relative(process.cwd(), target)}`);
+          log2(`  wrote   ${path9.relative(process.cwd(), target)}`);
         }
         upsert(lock, key, {
           status: "downloaded",
@@ -3026,10 +3469,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = path8.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path9.join(cacheDir, cacheFileName(hash, mediaType));
   if (!existsSync6(file)) return null;
   try {
-    const buf = await readFile4(file);
+    const buf = await readFile5(file);
     if (sha256(buf) !== hash) return null;
     validateMedia(buf, mediaType);
     return buf;
@@ -3040,7 +3483,7 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = path8.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path9.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
   await mkdir2(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
@@ -3083,7 +3526,7 @@ async function pushTags(provider, specs, lock, opts = {}) {
 // src/pipeline/doctor.ts
 import { constants, existsSync as existsSync7 } from "fs";
 import { access, stat as stat2 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message2) => checks.push({ id, level, message: message2 });
@@ -3093,7 +3536,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     `${Object.keys(loaded.manifest.styles).length} style(s), ${Object.keys(loaded.manifest.assets).length} asset(s), ${specs.length} resolved spec(s)`
   );
   add("lock", "ok", `${Object.keys(lock.entries).length} valid v2 lock entr(ies)`);
-  const dirs = [...new Set(specs.map((s) => path9.dirname(s.outFile)))];
+  const dirs = [...new Set(specs.map((s) => path10.dirname(s.outFile)))];
   const unwritable = [];
   for (const dir of dirs) {
     const ancestor = await nearestExistingDirectory(dir);
@@ -3115,7 +3558,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     for (let index = 0; index < entry.outputs.length; index++) {
       const output = entry.outputs[index];
       const spec = specByKey.get(key);
-      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path9.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path10.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -3130,7 +3573,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   } else {
     add("lock-outputs", "ok", `${outputOwners.size} recorded output path(s) are uniquely owned`);
   }
-  const cacheDir = path9.join(path9.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = path10.join(path10.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -3146,7 +3589,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     const hasSource = Boolean(entry.sourceUrl || entry.sourceUrls?.length);
     let hasCache = false;
     for (const output of entry.outputs) {
-      const cached = path9.join(
+      const cached = path10.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
@@ -3181,8 +3624,15 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
       "error",
       opts.apiKeyPresent === false ? `${opts.credentialEnv ?? "PIXELLAB_API_KEY"} is not configured` : "provider is not configured"
     );
+  } else if (!opts.provider.balance && !opts.provider.checkConnection) {
+    add("provider", "ok", `${opts.provider.id} configured; connectivity check unavailable`);
   } else if (!opts.provider.balance) {
-    add("provider", "ok", `${opts.provider.id} configured; balance reporting unavailable`);
+    try {
+      await opts.provider.checkConnection();
+      add("provider", "ok", `${opts.provider.id} reachable; balance reporting unavailable`);
+    } catch (err) {
+      add("provider", "error", `provider connectivity failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
   } else {
     const balanceFn = opts.provider.balance.bind(opts.provider);
     try {
@@ -3201,7 +3651,7 @@ async function nearestExistingDirectory(start) {
       if ((await stat2(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = path9.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
@@ -3209,11 +3659,11 @@ async function nearestExistingDirectory(start) {
 
 // src/pipeline/adopt.ts
 import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import path11 from "path";
 
 // src/cache.ts
-import { mkdir as mkdir3, readFile as readFile5, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile6, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import pathModule from "path";
 import { z as z3 } from "zod";
@@ -3229,10 +3679,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path19) {
-  if (!existsSync8(path19)) return { version: 1, hashes: {} };
+async function loadCache(path20) {
+  if (!existsSync8(path20)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile5(path19, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile6(path20, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -3244,18 +3694,18 @@ async function loadCache(path19) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path19, cache) {
+async function saveCache(path20, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await mkdir3(pathModule.dirname(pathModule.resolve(path19)), { recursive: true });
-  const tmp = `${path19}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir3(pathModule.dirname(pathModule.resolve(path20)), { recursive: true });
+  const tmp = `${path20}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile3(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename3(tmp, path19);
+    await rename3(tmp, path20);
   } finally {
     await rm3(tmp, { force: true });
   }
@@ -3290,7 +3740,7 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
-    const bytes = await readFile6(spec.outFile);
+    const bytes = await readFile7(spec.outFile);
     try {
       decodePng(bytes);
     } catch (err) {
@@ -3407,7 +3857,7 @@ async function tagAdopted(provider, specs, lock, opts = {}) {
 async function writePromptsBack(manifestPath, lock, opts = {}) {
   const log2 = opts.onProgress ?? (() => {
   });
-  const raw = JSON.parse(await readFile6(manifestPath, "utf8"));
+  const raw = JSON.parse(await readFile7(manifestPath, "utf8"));
   const best = /* @__PURE__ */ new Map();
   for (const entry of Object.values(lock.entries)) {
     if (!entry.objectId || !entry.prompt) continue;
@@ -3797,9 +4247,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/init.ts
-import { readdir, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { readdir, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
-import path11 from "path";
+import path12 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -3813,7 +4263,7 @@ function slugify(value) {
 async function walk(dir, exclude) {
   const out = [];
   for (const entry of await readdir(dir, { withFileTypes: true })) {
-    const full = path11.join(dir, entry.name);
+    const full = path12.join(dir, entry.name);
     if (exclude.some((x) => full.includes(x))) continue;
     if (entry.isDirectory()) out.push(...await walk(full, exclude));
     else if (entry.name.toLowerCase().endsWith(".png")) out.push(full);
@@ -3827,14 +4277,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await readFile7(file));
+    const size = pngSize(await readFile8(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = path11.relative(root, file);
-    const category = path11.dirname(rel) === "." ? "" : path11.dirname(rel);
-    let id = slugify(path11.basename(rel));
+    const rel = path12.relative(root, file);
+    const category = path12.dirname(rel) === "." ? "" : path12.dirname(rel);
+    let id = slugify(path12.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -3896,16 +4346,16 @@ async function writeManifestFile(target, manifest) {
 }
 
 // src/pipeline/salvage.ts
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
-import path12 from "path";
+import path13 from "path";
 async function loadClaims(lockPaths) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
     if (!existsSync11(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile8(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile9(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -3947,20 +4397,20 @@ function matchStyleByPattern(prompt, manifest) {
   return null;
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path12.resolve(ownManifestPath);
+  const own = path13.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path12.join(path12.dirname(path12.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path13.join(path13.dirname(path13.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path12.resolve(siblingManifestPath) === own) continue;
+    if (path13.resolve(siblingManifestPath) === own) continue;
     if (!existsSync11(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path12.basename(path12.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path13.basename(path13.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -4076,9 +4526,9 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/workspace.ts
-import { mkdir as mkdir4, readFile as readFile9, rename as rename4, rm as rm4, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile10, rename as rename4, rm as rm4, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import path13 from "path";
+import path14 from "path";
 import { z as z4 } from "zod";
 var WorkspaceProjectSchema = z4.object({
   id: z4.string().min(1),
@@ -4106,7 +4556,7 @@ async function loadWorkspace(workspacePath) {
   if (!existsSync12(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await readFile9(workspacePath, "utf8"));
+    raw = JSON.parse(await readFile10(workspacePath, "utf8"));
   } catch (err) {
     throw new Error(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -4120,7 +4570,7 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await mkdir4(path13.dirname(path13.resolve(workspacePath)), { recursive: true });
+  await mkdir4(path14.dirname(path14.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile6(tmp, JSON.stringify(sorted, null, 2) + "\n");
@@ -4130,12 +4580,12 @@ async function saveWorkspace(workspacePath, ws) {
   }
 }
 function toPortablePath(dir, absolute) {
-  return path13.relative(dir, absolute).split(path13.sep).join("/");
+  return path14.relative(dir, absolute).split(path14.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: path13.resolve(dir, project.manifest.split("/").join(path13.sep)),
-    lockPath: path13.resolve(dir, project.lock.split("/").join(path13.sep))
+    manifestPath: path14.resolve(dir, project.manifest.split("/").join(path14.sep)),
+    lockPath: path14.resolve(dir, project.lock.split("/").join(path14.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -4148,7 +4598,7 @@ function validateWorkspace(ws, dir) {
     const { manifestPath, lockPath } = resolveProject(dir, project);
     lockOwners.set(lockPath, [...lockOwners.get(lockPath) ?? [], project.id]);
     manifestOwners.set(manifestPath, [...manifestOwners.get(manifestPath) ?? [], project.id]);
-    if (path13.isAbsolute(project.manifest) || path13.isAbsolute(project.lock)) {
+    if (path14.isAbsolute(project.manifest) || path14.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
@@ -4303,9 +4753,9 @@ async function workspaceStatus(ws, dir) {
 }
 
 // src/pipeline/audit.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
-import path14 from "path";
+import path15 from "path";
 function colorDistance(a, b) {
   const rmean = (a.r + b.r) / 2;
   const dr = a.r - b.r;
@@ -4355,7 +4805,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
         continue;
       }
       try {
-        const png = decodePng(await readFile10(output.absolutePath));
+        const png = decodePng(await readFile11(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -4379,10 +4829,10 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = path14.resolve(loaded.root, img.path);
+    const abs = path15.resolve(loaded.root, img.path);
     if (!existsSync13(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await readFile10(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await readFile11(abs)), 12));
     } catch {
     }
   }
@@ -4459,14 +4909,14 @@ function hex(c) {
 
 // src/pipeline/cache-health.ts
 import { existsSync as existsSync14 } from "fs";
-import { readFile as readFile11, readdir as readdir2, rm as rm5 } from "fs/promises";
-import path15 from "path";
+import { readFile as readFile12, readdir as readdir2, rm as rm5 } from "fs/promises";
+import path16 from "path";
 async function inspectCaches(lock, lockPath, options = {}) {
   if (options.prune && !existsSync14(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path15.resolve(lockPath)}`);
+    throw new Error(`Refusing to prune without an existing lockfile at ${path16.resolve(lockPath)}`);
   }
-  const contentDir = path15.resolve(path15.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path15.resolve(cachePathFor(lockPath));
+  const contentDir = path16.resolve(path16.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path16.resolve(cachePathFor(lockPath));
   const referenced = new Set(
     Object.values(lock.entries).flatMap((entry) => entry.outputs.map((output) => output.sha256))
   );
@@ -4480,7 +4930,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm5(path15.join(contentDir, name), { force: true });
+        await rm5(path16.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -4489,7 +4939,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
       await saveCache(remotePath, { version: 1, hashes: {} });
       removed.resetRemoteHashCache = true;
     } else if (remoteHashes.invalidIds.length) {
-      const cache = parseCache(JSON.parse(await readFile11(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile12(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -4528,12 +4978,12 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path15.join(contentDir, entry.name);
+    const file = path16.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile11(file);
+      bytes = await readFile12(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -4580,7 +5030,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile11(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile12(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -4851,8 +5301,8 @@ function isRecord(value) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir5, writeFile as writeFile7, readFile as readFile12 } from "fs/promises";
-import path16 from "path";
+import { mkdir as mkdir5, writeFile as writeFile7, readFile as readFile13 } from "fs/promises";
+import path17 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml2 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -5017,7 +5467,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path16.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path17.relative(process.cwd(), ctx.importDir) || "."
   });
   const byId = new Map(orphans.map((o) => [o.id, o]));
   const existingTags = new Map(orphans.map((o) => [o.id, o.tags]));
@@ -5046,9 +5496,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE2)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = path16.join("_salvaged", `${assetId}.png`);
-            const outFile = path16.resolve(ctx.importDir, rel);
-            await mkdir5(path16.dirname(outFile), { recursive: true });
+            const rel = path17.join("_salvaged", `${assetId}.png`);
+            const outFile = path17.resolve(ctx.importDir, rel);
+            await mkdir5(path17.dirname(outFile), { recursive: true });
             await writeFile7(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
@@ -5075,7 +5525,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               error: null,
               sourceUrl: orphan.previewUrl,
               outputs: [{
-                path: portableOutputPath(outFile, path16.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path17.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -5099,7 +5549,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log2 });
-      const raw = JSON.parse(await readFile12(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile13(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
       await writeFile7(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
@@ -5109,9 +5559,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 }
 
 // src/artifacts.ts
-import path17 from "path";
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir6, readFile as readFile13, rename as rename5, rm as rm6, writeFile as writeFile8 } from "fs/promises";
+import path18 from "path";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir6, readFile as readFile14, rename as rename5, rm as rm6, writeFile as writeFile8 } from "fs/promises";
 var activeTransactions = /* @__PURE__ */ new Set();
 function message(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5120,27 +5570,27 @@ function digest(data) {
   return createHash2("sha256").update(data).digest("hex");
 }
 function portableRelative(from, to) {
-  return path17.relative(from, path17.resolve(to)).split(path17.sep).join("/") || ".";
+  return path18.relative(from, path18.resolve(to)).split(path18.sep).join("/") || ".";
 }
-function canonical(value) {
+function canonical2(value) {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value;
   if (typeof value === "number") {
     if (!Number.isFinite(value)) throw new Error("Artifact provenance numbers must be finite.");
     return value;
   }
-  if (Array.isArray(value)) return value.map(canonical);
+  if (Array.isArray(value)) return value.map(canonical2);
   if (typeof value === "object") {
     const sorted = {};
     for (const key of Object.keys(value).sort()) {
       const item = value[key];
-      if (item !== void 0) sorted[key] = canonical(item);
+      if (item !== void 0) sorted[key] = canonical2(item);
     }
     return sorted;
   }
   throw new Error(`Artifact provenance cannot contain ${typeof value} values.`);
 }
 function fingerprint(provenance) {
-  return digest(JSON.stringify(canonical({
+  return digest(JSON.stringify(canonical2({
     kind: provenance.kind,
     sources: provenance.sources,
     options: provenance.options,
@@ -5171,7 +5621,7 @@ function parseArtifactManifest(absolute, data) {
 }
 async function readOptional(file) {
   try {
-    return await readFile13(file);
+    return await readFile14(file);
   } catch (error) {
     if (isCode(error, "ENOENT")) return null;
     throw error;
@@ -5190,8 +5640,8 @@ function processIsAlive(pid) {
   }
 }
 function validTemporaryPath(candidate, destination, type) {
-  return path17.dirname(candidate) === path17.dirname(destination) && path17.basename(candidate).startsWith(
-    `.${path17.basename(destination)}.pixelkiln-${type}-`
+  return path18.dirname(candidate) === path18.dirname(destination) && path18.basename(candidate).startsWith(
+    `.${path18.basename(destination)}.pixelkiln-${type}-`
   );
 }
 function parseTransaction(journal, data) {
@@ -5211,7 +5661,7 @@ async function removeTransactionFiles(journal) {
   await rm6(transactionMarker(journal), { force: true });
 }
 async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
-  const journal = path17.resolve(recoveryFile);
+  const journal = path18.resolve(recoveryFile);
   const bytes = await readOptional(journal);
   if (!bytes) {
     await rm6(transactionMarker(journal), { force: true });
@@ -5227,7 +5677,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(path17.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(path18.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.`
       );
@@ -5273,7 +5723,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
   await removeTransactionFiles(journal);
 }
 function createArtifactBundleManifest(manifestPath, outputs, provenance) {
-  const root = path17.dirname(path17.resolve(manifestPath));
+  const root = path18.dirname(path18.resolve(manifestPath));
   const sources = provenance.sources.map((source) => ({
     ...source,
     path: portableRelative(root, source.path)
@@ -5281,7 +5731,7 @@ function createArtifactBundleManifest(manifestPath, outputs, provenance) {
   const normalized = {
     kind: provenance.kind,
     sources,
-    options: canonical(provenance.options)
+    options: canonical2(provenance.options)
   };
   const manifestOutputs = outputs.map((output) => ({
     path: portableRelative(root, output.path),
@@ -5303,11 +5753,11 @@ function withArtifactManifest(manifestPath, outputs, provenance) {
   ];
 }
 async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
-  const absoluteManifest = path17.resolve(manifestPath);
+  const absoluteManifest = path18.resolve(manifestPath);
   const recoveryFile = `${absoluteManifest}.transaction`;
   const allowedDestinations = /* @__PURE__ */ new Set([
     absoluteManifest,
-    ...outputs.map((output) => path17.resolve(output.path))
+    ...outputs.map((output) => path18.resolve(output.path))
   ]);
   await recoverArtifactTransaction(recoveryFile, allowedDestinations);
   const existingManifestBytes = await readOptional(absoluteManifest);
@@ -5325,13 +5775,13 @@ async function writeManagedArtifactBundle(manifestPath, outputs, provenance, opt
     }
   }
   if (!options.force) {
-    const root = path17.dirname(absoluteManifest);
+    const root = path18.dirname(absoluteManifest);
     const recorded = new Map(
-      previous?.outputs.map((output) => [path17.resolve(root, output.path), output.sha256]) ?? []
+      previous?.outputs.map((output) => [path18.resolve(root, output.path), output.sha256]) ?? []
     );
     const conflicts = [];
     for (const output of outputs) {
-      const destination = path17.resolve(output.path);
+      const destination = path18.resolve(output.path);
       const current = await readOptional(destination);
       if (!current || digest(current) === digest(output.data)) continue;
       const expected = recorded.get(destination);
@@ -5386,7 +5836,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: path17.resolve(file.path), data: Buffer.from(file.data) };
+    return { destination: path18.resolve(file.path), data: Buffer.from(file.data) };
   });
   const destinations = /* @__PURE__ */ new Set();
   for (const artifact of normalized) {
@@ -5402,7 +5852,7 @@ async function writeArtifactBundle(files, options = {}) {
   const unchanged = [];
   for (const artifact of normalized) {
     try {
-      const current = await readFile13(artifact.destination);
+      const current = await readFile14(artifact.destination);
       if (current.equals(artifact.data)) {
         unchanged.push(artifact.destination);
       } else {
@@ -5414,23 +5864,23 @@ async function writeArtifactBundle(files, options = {}) {
     }
   }
   if (!changed.length) return { changed: [], unchanged };
-  const token = randomUUID2();
+  const token = randomUUID3();
   for (const [index, artifact] of changed.entries()) {
-    const basename = path17.basename(artifact.destination);
-    artifact.stage = path17.join(
-      path17.dirname(artifact.destination),
+    const basename = path18.basename(artifact.destination);
+    artifact.stage = path18.join(
+      path18.dirname(artifact.destination),
       `.${basename}.pixelkiln-stage-${token}-${index}`
     );
     if (artifact.existed) {
-      artifact.backup = path17.join(
-        path17.dirname(artifact.destination),
+      artifact.backup = path18.join(
+        path18.dirname(artifact.destination),
         `.${basename}.pixelkiln-backup-${token}-${index}`
       );
     }
   }
-  const journal = options.recoveryFile ? path17.resolve(options.recoveryFile) : null;
+  const journal = options.recoveryFile ? path18.resolve(options.recoveryFile) : null;
   if (journal) {
-    await mkdir6(path17.dirname(journal), { recursive: true });
+    await mkdir6(path18.dirname(journal), { recursive: true });
     const transaction = {
       format: "pixelkiln-artifact-transaction",
       version: 1,
@@ -5455,7 +5905,7 @@ async function writeArtifactBundle(files, options = {}) {
   }
   try {
     for (const [index, artifact] of changed.entries()) {
-      await mkdir6(path17.dirname(artifact.destination), { recursive: true });
+      await mkdir6(path18.dirname(artifact.destination), { recursive: true });
       await options.beforeStage?.(artifact.destination, index);
       await writeFile8(artifact.stage, artifact.data, { flag: "wx" });
     }
@@ -5525,7 +5975,7 @@ async function writeArtifactBundle(files, options = {}) {
 // src/cli.ts
 var log = (msg = "") => console.log(msg);
 async function provenanceFile(id, file) {
-  const absolute = path18.resolve(file);
+  const absolute = path19.resolve(file);
   return {
     id,
     path: absolute,
@@ -5708,7 +6158,7 @@ function parseArgs(argv) {
   return {
     command,
     manifest,
-    lock: get("--lock") ?? path18.join(path18.dirname(path18.resolve(manifest)), "pixelkiln.lock.json"),
+    lock: get("--lock") ?? path19.join(path19.dirname(path19.resolve(manifest)), "pixelkiln.lock.json"),
     explicitLock: get("--lock"),
     styles: list("--style"),
     assets: list("--only"),
@@ -5866,7 +6316,7 @@ async function requireCompleteWorkspaceClaims(workspacePath) {
   if (!existsSync15(workspacePath)) {
     throw new Error(`Workspace catalog not found: ${workspacePath}`);
   }
-  const dir = path18.dirname(path18.resolve(workspacePath));
+  const dir = path19.dirname(path19.resolve(workspacePath));
   const ws = await loadWorkspace(workspacePath);
   const diagnostics = validateWorkspace(ws, dir);
   const errors = diagnostics.filter((d) => d.level === "error");
@@ -5887,13 +6337,13 @@ async function main() {
   }
   if (args.command === "--version" || args.command === "-v") {
     const pkg = JSON.parse(
-      await readFile14(new URL("../package.json", import.meta.url), "utf8")
+      await readFile15(new URL("../package.json", import.meta.url), "utf8")
     );
     log(`${pkg.name} ${pkg.version}`);
     return;
   }
   if (args.command === "balance") {
-    loadEnvFiles(path18.dirname(path18.resolve(args.manifest)));
+    loadEnvFiles(path19.dirname(path19.resolve(args.manifest)));
     loadEnvFiles(process.cwd());
     const loaded2 = await loadManifest(args.manifest);
     const p = createProvider(loaded2.manifest.provider, "online");
@@ -5905,31 +6355,31 @@ async function main() {
   }
   if (args.command === "init") {
     if (!args.from) throw new Error("init needs --from <dir> pointing at your existing PNGs.");
-    const root = path18.resolve(args.from);
+    const root = path19.resolve(args.from);
     if (!existsSync15(root)) throw new Error(`No directory at ${root}`);
     const generator = args.generator ?? "map";
     if (generator !== "1dir" && generator !== "map") {
       throw new Error(`--generator must be "1dir" or "map", got "${args.generator}".`);
     }
-    const target = path18.resolve(args.out ?? "pixelkiln.manifest.json");
+    const target = path19.resolve(args.out ?? "pixelkiln.manifest.json");
     const { assets, skipped } = await scanAssets(root, { exclude: args.exclude });
     if (!assets.length) throw new Error(`No PNGs found under ${root}`);
     const manifest = buildManifest(
-      args.name ?? path18.basename(path18.dirname(target)),
+      args.name ?? path19.basename(path19.dirname(target)),
       args.styles[0] ?? "base",
       generator,
-      path18.relative(path18.dirname(target), root) || ".",
+      path19.relative(path19.dirname(target), root) || ".",
       assets
     );
     await writeManifestFile(target, manifest);
-    log(`  scanned ${assets.length} PNG(s) under ${path18.relative(process.cwd(), root)}`);
+    log(`  scanned ${assets.length} PNG(s) under ${path19.relative(process.cwd(), root)}`);
     if (skipped.length) log(`  skipped ${skipped.length} unreadable file(s)`);
-    log(`  wrote ${path18.relative(process.cwd(), target)}`);
+    log(`  wrote ${path19.relative(process.cwd(), target)}`);
     log(`
   Prompts are intentionally empty. To recover the real ones from your`);
     log(`  PixelLab account instead of inventing them:`);
     log(`
-    pixelkiln adopt --manifest ${path18.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path19.relative(process.cwd(), target)} --write-prompts
 `);
     return;
   }
@@ -5977,10 +6427,10 @@ async function main() {
     if (args.primaryOnly || args.outputRoles.length) {
       throw new Error("--primary-only and --output-role require manifest-driven pack");
     }
-    const raw = JSON.parse(await readFile14(path18.resolve(args.inputs), "utf8"));
+    const raw = JSON.parse(await readFile15(path19.resolve(args.inputs), "utf8"));
     const inputs = resolvePackInputs(raw, args.inputs);
     const { png, atlas, skipped, sources } = packSprites(inputs, { columns: args.columns });
-    const base = path18.resolve(args.out.replace(/\.png$/, ""));
+    const base = path19.resolve(args.out.replace(/\.png$/, ""));
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -5993,17 +6443,17 @@ async function main() {
     log(
       `  ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s) \u2014 ${(png.length / 1024).toFixed(1)} KB`
     );
-    log(`    ${path18.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+    log(`    ${path19.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     return;
   }
   if (args.command === "workspace") {
-    const workspacePath = path18.resolve(args.workspace ?? "pixelkiln.workspace.json");
-    const dir = path18.dirname(workspacePath);
+    const workspacePath = path19.resolve(args.workspace ?? "pixelkiln.workspace.json");
+    const dir = path19.dirname(workspacePath);
     if (args.subcommand === "add") {
-      const manifestPath = path18.resolve(args.target);
+      const manifestPath = path19.resolve(args.target);
       const loadedTarget = await loadManifest(manifestPath);
-      const lockPath = args.explicitLock ? path18.resolve(args.explicitLock) : path18.join(path18.dirname(manifestPath), "pixelkiln.lock.json");
+      const lockPath = args.explicitLock ? path19.resolve(args.explicitLock) : path19.join(path19.dirname(manifestPath), "pixelkiln.lock.json");
       const ws = await loadWorkspace(workspacePath);
       const id = args.name ?? loadedTarget.manifest.name;
       if (ws.projects.some((p) => p.id === id)) {
@@ -6023,7 +6473,7 @@ async function main() {
         ...args.account ? { account: args.account } : {}
       };
       await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-      log(`  registered "${id}" in ${path18.relative(process.cwd(), workspacePath)}`);
+      log(`  registered "${id}" in ${path19.relative(process.cwd(), workspacePath)}`);
       log(`    manifest: ${project.manifest}`);
       log(`    lock:     ${project.lock}`);
       if (!existsSync15(lockPath)) {
@@ -6035,7 +6485,7 @@ async function main() {
     }
     if (args.subcommand === "remove") {
       const ws = await loadWorkspace(workspacePath);
-      const resolvedTarget = path18.resolve(args.target);
+      const resolvedTarget = path19.resolve(args.target);
       const match = ws.projects.find(
         (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
       );
@@ -6046,7 +6496,7 @@ async function main() {
         version: 1,
         projects: ws.projects.filter((p) => p !== match)
       });
-      log(`  removed "${match.id}" from ${path18.relative(process.cwd(), workspacePath)}`);
+      log(`  removed "${match.id}" from ${path19.relative(process.cwd(), workspacePath)}`);
       return;
     }
     if (args.subcommand === "list") {
@@ -6058,9 +6508,9 @@ async function main() {
       if (args.json) {
         log(JSON.stringify({ version: 1, workspace: workspacePath, projects: ws.projects, diagnostics }, null, 2));
       } else if (!ws.projects.length) {
-        log(`  no projects registered in ${path18.relative(process.cwd(), workspacePath)}`);
+        log(`  no projects registered in ${path19.relative(process.cwd(), workspacePath)}`);
       } else {
-        log(`  ${ws.projects.length} project(s) in ${path18.relative(process.cwd(), workspacePath)}:`);
+        log(`  ${ws.projects.length} project(s) in ${path19.relative(process.cwd(), workspacePath)}:`);
         for (const p of ws.projects) {
           log(`    ${p.id.padEnd(24)} ${p.manifest.padEnd(40)} (${p.provider}${p.account ? `, ${p.account}` : ""})`);
         }
@@ -6078,7 +6528,7 @@ async function main() {
       if (args.json) {
         log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
       } else {
-        log(`  workspace: ${path18.relative(process.cwd(), workspacePath)}`);
+        log(`  workspace: ${path19.relative(process.cwd(), workspacePath)}`);
         for (const p of report.projects) {
           if (p.error) {
             log(`
@@ -6122,14 +6572,14 @@ async function main() {
       return;
     }
   }
-  if (!existsSync15(path18.resolve(args.manifest))) {
+  if (!existsSync15(path19.resolve(args.manifest))) {
     throw new Error(
-      `No manifest at ${path18.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
+      `No manifest at ${path19.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
     );
   }
-  const manifestDir = path18.dirname(path18.resolve(args.manifest));
+  const manifestDir = path19.dirname(path19.resolve(args.manifest));
   const envFiles = [...loadEnvFiles(manifestDir)];
-  if (path18.resolve(process.cwd()) !== manifestDir) envFiles.push(...loadEnvFiles(process.cwd()));
+  if (path19.resolve(process.cwd()) !== manifestDir) envFiles.push(...loadEnvFiles(process.cwd()));
   const loaded = await loadManifest(args.manifest);
   const estimator = createProvider(loaded.manifest.provider, "offline");
   const specs = await resolveSpecs(loaded, {
@@ -6264,7 +6714,7 @@ async function main() {
     if (args.primaryOnly && args.outputRoles.length) {
       throw new Error("pack accepts either --primary-only or --output-role, not both");
     }
-    const manifestDir2 = path18.dirname(path18.resolve(args.manifest));
+    const manifestDir2 = path19.dirname(path19.resolve(args.manifest));
     const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
     for (const styleId of styleIds) {
       const { png, atlas, skipped, sources } = packStyle(lock, styleId, manifestDir2, {
@@ -6273,7 +6723,7 @@ async function main() {
         primaryOnly: args.primaryOnly
       });
       const style = loaded.manifest.styles[styleId];
-      const base = args.out ? path18.resolve(args.out.replace(/\.png$/, "")) : path18.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
+      const base = args.out ? path19.resolve(args.out.replace(/\.png$/, "")) : path19.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
       const outputs = [
         { path: `${base}.png`, data: png },
         { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -6296,13 +6746,13 @@ async function main() {
       log(
         `  ${styleId} \u2014 ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s)`
       );
-      log(`    ${path18.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+      log(`    ${path19.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
       for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     }
     return;
   }
   if (args.command === "mount") {
-    const manifestDir2 = path18.dirname(path18.resolve(args.manifest));
+    const manifestDir2 = path19.dirname(path19.resolve(args.manifest));
     const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
     for (const styleId of styleIds) {
       const style = loaded.manifest.styles[styleId];
@@ -6332,7 +6782,7 @@ async function main() {
         sources,
         outputRoles
       );
-      const out = path18.resolve(manifestDir2, style.mount.out);
+      const out = path19.resolve(manifestDir2, style.mount.out);
       const metadata = out.replace(/\.png$/, "") + ".json";
       const companion = out.replace(/\.png$/, "") + ".pixelkiln.json";
       const outputs = [
@@ -6345,7 +6795,7 @@ async function main() {
           await provenanceFile("$manifest", args.manifest),
           await provenanceFile("$lock", args.lock),
           ...artifactSources.filter(
-            (source) => source.id !== "$base" || path18.resolve(source.path) !== out
+            (source) => source.id !== "$base" || path19.resolve(source.path) !== out
           )
         ],
         options: {
@@ -6358,7 +6808,7 @@ async function main() {
       log(
         `  ${styleId} \u2014 ${atlas.frames.length} cell(s) into ${atlas.sheet.width}x${atlas.sheet.height}` + (overBase ? ` over ${style.mount.base}` : " (new sheet)")
       );
-      log(`    ${path18.relative(process.cwd(), out)} + atlas/provenance JSON`);
+      log(`    ${path19.relative(process.cwd(), out)} + atlas/provenance JSON`);
       for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     }
     return;
@@ -6414,7 +6864,7 @@ async function main() {
   }
   if (args.command === "export") {
     const format = args.format ?? "generic";
-    const manifestDir2 = path18.dirname(path18.resolve(args.manifest));
+    const manifestDir2 = path19.dirname(path19.resolve(args.manifest));
     const selected = specs.filter((spec) => {
       if (spec.generator !== "tiles") return false;
       if (args.styles.length && !args.styles.includes(spec.styleId)) return false;
@@ -6430,12 +6880,12 @@ async function main() {
     for (const spec of selected) {
       const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
       const style = loaded.manifest.styles[spec.styleId];
-      const defaultBase = path18.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
-      const base = args.out ? path18.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
+      const defaultBase = path19.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
+      const base = args.out ? path19.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
       const result = exportTileset(entry, spec, {
         format,
         manifestDir: manifestDir2,
-        imageName: path18.basename(`${base}.png`),
+        imageName: path19.basename(`${base}.png`),
         columns: args.columns
       });
       const outputs = [
@@ -6453,7 +6903,7 @@ async function main() {
           asset: spec.assetId,
           columns: args.columns ?? null,
           format,
-          image: path18.basename(`${base}.png`),
+          image: path19.basename(`${base}.png`),
           providerRules: result.generic.providerRules,
           style: spec.styleId,
           tileType: spec.tileType ?? null
@@ -6463,7 +6913,7 @@ async function main() {
         `  ${spec.styleId}/${spec.assetId} \u2014 ${result.generic.tiles.length} tile(s), ${result.generic.sheet.width}x${result.generic.sheet.height} (${format})`
       );
       log(
-        `    ${path18.relative(process.cwd(), base)}.png + ${path18.basename(base)}${result.extension} + .pixelkiln.json`
+        `    ${path19.relative(process.cwd(), base)}.png + ${path19.basename(base)}${result.extension} + .pixelkiln.json`
       );
     }
     return;
@@ -6503,10 +6953,10 @@ async function main() {
   tagged ${n} object(s) upstream`);
     }
     if (args.writePrompts) {
-      const { filled, stillEmpty } = await writePromptsBack(path18.resolve(args.manifest), lock, {
+      const { filled, stillEmpty } = await writePromptsBack(path19.resolve(args.manifest), lock, {
         onProgress: log
       });
-      log(`  recovered ${filled} prompt(s) into ${path18.relative(process.cwd(), args.manifest)}`);
+      log(`  recovered ${filled} prompt(s) into ${path19.relative(process.cwd(), args.manifest)}`);
       const reloaded = await loadManifest(args.manifest);
       const rebased = await resolveSpecs(reloaded, {
         styles: args.styles,
@@ -6535,12 +6985,12 @@ async function main() {
   if (args.command === "salvage") {
     const jsonMode = args.dryRun && args.json;
     const diag = jsonMode ? (msg = "") => console.error(msg) : log;
-    const ownLock = path18.resolve(args.lock);
+    const ownLock = path19.resolve(args.lock);
     let workspaceProjects = [];
     let workspaceDir = "";
     if (args.workspace) {
-      const workspacePath = path18.resolve(args.workspace);
-      workspaceDir = path18.dirname(workspacePath);
+      const workspacePath = path19.resolve(args.workspace);
+      workspaceDir = path19.dirname(workspacePath);
       const complete = await requireCompleteWorkspaceClaims(workspacePath);
       workspaceProjects = complete.ws.projects;
       for (const d of complete.diagnostics) diag(`  WARN  ${d.id}: ${d.message}`);
@@ -6550,11 +7000,11 @@ async function main() {
       .../* @__PURE__ */ new Set([
         ...workspaceLockPaths,
         ...existsSync15(ownLock) ? [ownLock] : [],
-        ...args.claims.map((c) => path18.resolve(c))
+        ...args.claims.map((c) => path19.resolve(c))
       ])
     ];
     diag(`  claim set (${lockPaths.length} lockfile(s)):`);
-    for (const p of lockPaths) diag(`    ${path18.relative(process.cwd(), p)}`);
+    for (const p of lockPaths) diag(`    ${path19.relative(process.cwd(), p)}`);
     if (!args.claims.length && !args.workspace) {
       diag(
         `
@@ -6562,7 +7012,7 @@ async function main() {
   pass every other project's lockfile via --claims a.json,b.json, or
   register every project in a workspace catalog and pass --workspace.`
       );
-    } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path18.resolve(args.manifest))) {
+    } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path19.resolve(args.manifest))) {
       diag(
         `
   This project's manifest is not registered in the workspace catalog. Its own
@@ -6646,7 +7096,7 @@ async function main() {
           manifestPath: loaded.path,
           manifest: loaded.manifest,
           styleId,
-          importDir: path18.resolve(loaded.root, style.outDir),
+          importDir: path19.resolve(loaded.root, style.outDir),
           lock,
           lockPath: args.lock
         },