pixelkiln 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AssetSchema: () => AssetSchema,
+  ComfyUIProvider: () => ComfyUIProvider,
   DEFAULT_RATE_LIMIT: () => DEFAULT_RATE_LIMIT,
   FAKE_PNG: () => FAKE_PNG,
   FakeProvider: () => FakeProvider,
@@ -202,8 +203,8 @@ var StyleSchema = import_zod.z.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: import_zod.z.number().int().min(32).max(256).optional(),
+  /** Square edge length. The active provider owns its exact limit. */
+  size: import_zod.z.number().int().min(16).max(8192).optional(),
   view: import_zod.z.string().optional(),
   /** Appended to every asset prompt in this style. Where the look is defined. */
   promptSuffix: import_zod.z.string().default(""),
@@ -319,8 +320,8 @@ var AssetSchema = import_zod.z.object({
   /** Subdirectory under the style's outDir. Optional. */
   category: import_zod.z.string().optional(),
   /** Overrides the style default. `map` generator only. */
-  width: import_zod.z.number().int().min(16).max(400).optional(),
-  height: import_zod.z.number().int().min(16).max(400).optional(),
+  width: import_zod.z.number().int().min(16).max(8192).optional(),
+  height: import_zod.z.number().int().min(16).max(8192).optional(),
   /** Overrides the style default. `1dir` generator only. */
   size: import_zod.z.number().int().min(32).max(256).optional(),
   /** Explicit output path relative to outDir. Media-aware providers may replace its extension. */
@@ -578,11 +579,11 @@ var PixelLabClient = class {
    * 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(path17, init, attempt = 0) {
+  async request(path18, init, attempt = 0) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
     let res;
     try {
-      res = await fetch(`${BASE}${path17}`, {
+      res = await fetch(`${BASE}${path18}`, {
         ...init,
         signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
         headers: {
@@ -594,24 +595,24 @@ var PixelLabClient = class {
     } catch (err) {
       if (attempt < MAX_RETRIES) {
         await sleep(backoffMs(attempt));
-        return this.request(path17, init, attempt + 1);
+        return this.request(path18, 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(path17, init, attempt + 1);
+      return this.request(path18, init, attempt + 1);
     }
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path17} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path18} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path17} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path18} returned invalid JSON`);
     }
   }
   async balance() {
@@ -1375,6 +1376,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, [
@@ -1651,9 +1658,9 @@ var RetroDiffusionClient = class {
     }
     return balance;
   }
-  async call(path17, init = {}) {
+  async call(path18, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path17}`, {
+    const response = await this.request(`${this.baseUrl}${path18}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -1923,8 +1930,470 @@ function retroError(value) {
   return JSON.stringify(value);
 }
 
-// src/providers/fake.ts
+// src/providers/comfyui.ts
+var import_node_crypto3 = require("crypto");
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/hash.ts
 var import_node_crypto2 = require("crypto");
+var import_promises = require("fs/promises");
+function sha256(data) {
+  return (0, import_node_crypto2.createHash)("sha256").update(data).digest("hex");
+}
+async function sha256File(path18) {
+  return sha256(await (0, import_promises.readFile)(path18));
+}
+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
+    })
+  );
+}
+
+// src/providers/comfyui.ts
+var DEFAULT_BASE_URL2 = "http://127.0.0.1:8188";
+var ComfyUIClient = class {
+  constructor(baseUrl = process.env.COMFYUI_BASE_URL ?? DEFAULT_BASE_URL2, 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: (0, import_node_crypto3.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_URL2));
+  }
+  static forDownloads() {
+    return new _ComfyUIProvider();
+  }
+  async resolveOptions(value, context) {
+    const options = parseOptions(value);
+    const workflowPath = import_node_path2.default.resolve(context.root, options.workflowFile);
+    let raw;
+    try {
+      raw = await (0, import_promises2.readFile)(workflowPath, "utf8");
+    } catch (err) {
+      throw new Error(
+        `ComfyUI workflow for style "${context.styleId}" could not be read at ${workflowPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    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/fake.ts
+var import_node_crypto4 = require("crypto");
 var FAKE_PNG = Buffer.from(
   "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
   "base64"
@@ -2008,7 +2477,7 @@ var FakeProvider = class {
   }
   async download(url) {
     if (!url.startsWith("fake://")) throw new Error(`fake provider cannot download ${url}`);
-    const salt = (0, import_node_crypto2.createHash)("sha256").update(url).digest();
+    const salt = (0, import_node_crypto4.createHash)("sha256").update(url).digest();
     return Buffer.concat([FAKE_PNG, salt.subarray(0, 4)]);
   }
   async balance() {
@@ -2107,56 +2576,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
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_node_fs2 = require("fs");
-var import_node_path2 = __toESM(require("path"), 1);
-
-// src/hash.ts
-var import_node_crypto3 = require("crypto");
-var import_promises = require("fs/promises");
-function sha256(data) {
-  return (0, import_node_crypto3.createHash)("sha256").update(data).digest("hex");
-}
-async function sha256File(path17) {
-  return sha256(await (0, import_promises.readFile)(path17));
-}
-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
+var import_node_path3 = __toESM(require("path"), 1);
 async function loadManifest(manifestPath) {
-  const abs = import_node_path2.default.resolve(manifestPath);
+  const abs = import_node_path3.default.resolve(manifestPath);
   if (!(0, import_node_fs2.existsSync)(abs)) throw new Error(`No manifest at ${abs}`);
-  const parsed = ManifestSchema.safeParse(JSON.parse(await (0, import_promises2.readFile)(abs, "utf8")));
+  const parsed = ManifestSchema.safeParse(JSON.parse(await (0, import_promises3.readFile)(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:
@@ -2178,7 +2614,7 @@ ${issues}`);
     throw new Error(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
-  return { manifest: parsed.data, root: import_node_path2.default.dirname(abs), path: abs };
+  return { manifest: parsed.data, root: import_node_path3.default.dirname(abs), path: abs };
 }
 async function resolveSpecs(loaded, filter) {
   const { manifest, root } = loaded;
@@ -2201,11 +2637,11 @@ async function resolveSpecs(loaded, filter) {
   }
   const styleImageCache = /* @__PURE__ */ new Map();
   async function loadStyleImage(rel) {
-    const abs = import_node_path2.default.resolve(root, rel);
+    const abs = import_node_path3.default.resolve(root, rel);
     let hit = styleImageCache.get(abs);
     if (!hit) {
       if (!(0, import_node_fs2.existsSync)(abs)) throw new Error(`Style image not found: ${abs}`);
-      const buf = await (0, import_promises2.readFile)(abs);
+      const buf = await (0, import_promises3.readFile)(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) {
@@ -2218,6 +2654,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) {
@@ -2250,15 +2690,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 ?? import_node_path2.default.join(asset.category ?? "", `${assetId}.png`);
-      const outFile = import_node_path2.default.resolve(root, style.outDir, relFile);
+      const relFile = asset.file ?? import_node_path3.default.join(asset.category ?? "", `${assetId}.png`);
+      const outFile = import_node_path3.default.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,
@@ -2296,10 +2736,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(import_node_path2.default.resolve(root, image.path));
+        const hit = styleImageCache.get(import_node_path3.default.resolve(root, image.path));
         return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
       });
       activeProvider.validate?.(resolved, resolvedImages);
@@ -2326,8 +2766,8 @@ async function resolveStyleImages(loaded, styleId) {
   if (!style) throw new Error(`Unknown style "${styleId}"`);
   const out = [];
   for (const img of style.styleImages) {
-    const file = import_node_path2.default.resolve(loaded.root, img.path);
-    const buf = await (0, import_promises2.readFile)(file);
+    const file = import_node_path3.default.resolve(loaded.root, img.path);
+    const buf = await (0, import_promises3.readFile)(file);
     const metadata = imageMetadata(buf);
     if (!metadata) throw new Error(`Style image is not a readable PNG or JPEG: ${file}`);
     if (metadata.width < 1 || metadata.height < 1) {
@@ -2370,13 +2810,13 @@ function imageMetadata(buf) {
 }
 
 // src/lock.ts
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 var import_node_fs3 = require("fs");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 async function loadLock(lockPath) {
   if (!(0, import_node_fs3.existsSync)(lockPath)) return { version: 2, entries: {} };
   try {
-    return parseLock(JSON.parse(await (0, import_promises3.readFile)(lockPath, "utf8")));
+    return parseLock(JSON.parse(await (0, import_promises4.readFile)(lockPath, "utf8")));
   } catch (err) {
     throw new Error(
       `Lockfile at ${lockPath} is malformed:
@@ -2388,7 +2828,7 @@ var saveQueues = /* @__PURE__ */ new Map();
 var dirtyPatches = /* @__PURE__ */ new WeakMap();
 var dirtyDeletes = /* @__PURE__ */ new WeakMap();
 function saveLock(lockPath, lock) {
-  const queueKey = import_node_path3.default.resolve(lockPath);
+  const queueKey = import_node_path4.default.resolve(lockPath);
   const previous = saveQueues.get(queueKey) ?? Promise.resolve();
   const next = previous.catch(() => {
   }).then(() => writeLockNow(lockPath, lock));
@@ -2400,7 +2840,7 @@ function saveLock(lockPath, lock) {
   return next;
 }
 async function writeLockNow(lockPath, lock) {
-  await (0, import_promises3.mkdir)(import_node_path3.default.dirname(import_node_path3.default.resolve(lockPath)), { recursive: true });
+  await (0, import_promises4.mkdir)(import_node_path4.default.dirname(import_node_path4.default.resolve(lockPath)), { recursive: true });
   const release = await acquireFileLock(lockPath);
   try {
     await writeLockWhileHeld(lockPath, lock);
@@ -2412,7 +2852,7 @@ async function writeLockWhileHeld(file, lock) {
   let disk = { version: 2, entries: {} };
   if ((0, import_node_fs3.existsSync)(file)) {
     try {
-      disk = parseLock(JSON.parse(await (0, import_promises3.readFile)(file, "utf8")));
+      disk = parseLock(JSON.parse(await (0, import_promises4.readFile)(file, "utf8")));
     } catch (err) {
       throw new Error(
         `Refusing to overwrite malformed lockfile at ${file}: ${err instanceof Error ? err.message : String(err)}`
@@ -2440,10 +2880,10 @@ async function writeLockWhileHeld(file, lock) {
   }
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises3.writeFile)(tmp, JSON.stringify({ version: 2, entries: sorted }, null, 2) + "\n");
-    await (0, import_promises3.rename)(tmp, file);
+    await (0, import_promises4.writeFile)(tmp, JSON.stringify({ version: 2, entries: sorted }, null, 2) + "\n");
+    await (0, import_promises4.rename)(tmp, file);
   } finally {
-    await (0, import_promises3.rm)(tmp, { force: true });
+    await (0, import_promises4.rm)(tmp, { force: true });
   }
   const currentDirty = dirtyPatches.get(lock);
   if (currentDirty) {
@@ -2506,18 +2946,18 @@ async function acquireFileLock(file) {
   const deadline = Date.now() + FILE_LOCK_TIMEOUT_MS;
   for (; ; ) {
     try {
-      await (0, import_promises3.mkdir)(lockDir);
+      await (0, import_promises4.mkdir)(lockDir);
       return async () => {
-        await (0, import_promises3.rmdir)(lockDir).catch(() => {
+        await (0, import_promises4.rmdir)(lockDir).catch(() => {
         });
       };
     } catch (err) {
       const code = err.code;
       if (code !== "EEXIST") throw err;
       try {
-        const age = Date.now() - (await (0, import_promises3.stat)(lockDir)).mtimeMs;
+        const age = Date.now() - (await (0, import_promises4.stat)(lockDir)).mtimeMs;
         if (age > STALE_FILE_LOCK_MS) {
-          await (0, import_promises3.rmdir)(lockDir);
+          await (0, import_promises4.rmdir)(lockDir);
           continue;
         }
       } catch (lockErr) {
@@ -2543,21 +2983,21 @@ function totalSpend(lock, unit = "generations") {
 }
 
 // src/outputs.ts
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 function portableOutputPath(file, manifestDir) {
-  const root = import_node_path4.default.resolve(manifestDir);
-  const absolute = import_node_path4.default.isAbsolute(file) ? import_node_path4.default.normalize(file) : import_node_path4.default.resolve(root, file);
-  const relative = import_node_path4.default.relative(root, absolute);
-  const value = import_node_path4.default.isAbsolute(relative) ? absolute : relative;
-  return value.split(import_node_path4.default.sep).join("/");
+  const root = import_node_path5.default.resolve(manifestDir);
+  const absolute = import_node_path5.default.isAbsolute(file) ? import_node_path5.default.normalize(file) : import_node_path5.default.resolve(root, file);
+  const relative = import_node_path5.default.relative(root, absolute);
+  const value = import_node_path5.default.isAbsolute(relative) ? absolute : relative;
+  return value.split(import_node_path5.default.sep).join("/");
 }
 function resolveOutputPath(recordedPath, manifestDir) {
-  if (import_node_path4.default.isAbsolute(recordedPath)) return import_node_path4.default.normalize(recordedPath);
-  if (import_node_path4.default.win32.isAbsolute(recordedPath)) return recordedPath;
-  return import_node_path4.default.resolve(manifestDir, recordedPath.split(/[\\/]/).join(import_node_path4.default.sep));
+  if (import_node_path5.default.isAbsolute(recordedPath)) return import_node_path5.default.normalize(recordedPath);
+  if (import_node_path5.default.win32.isAbsolute(recordedPath)) return recordedPath;
+  return import_node_path5.default.resolve(manifestDir, recordedPath.split(/[\\/]/).join(import_node_path5.default.sep));
 }
 function expectedOutputPath(spec, role, index, total, mediaType) {
-  const originalExt = import_node_path4.default.extname(spec.outFile);
+  const originalExt = import_node_path5.default.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}`;
@@ -2646,44 +3086,44 @@ function resolveSpecOutputs(spec, lock, manifestDir) {
     id: spec.assetId,
     index: 0,
     path: spec.outFile,
-    absolutePath: import_node_path4.default.resolve(spec.outFile),
+    absolutePath: import_node_path5.default.resolve(spec.outFile),
     sha256: ""
   }];
 }
 
 // src/artifacts.ts
-var import_node_path5 = __toESM(require("path"), 1);
-var import_node_crypto4 = require("crypto");
-var import_promises4 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_crypto5 = require("crypto");
+var import_promises5 = require("fs/promises");
 var activeTransactions = /* @__PURE__ */ new Set();
 function message(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function digest(data) {
-  return (0, import_node_crypto4.createHash)("sha256").update(data).digest("hex");
+  return (0, import_node_crypto5.createHash)("sha256").update(data).digest("hex");
 }
 function portableRelative(from, to) {
-  return import_node_path5.default.relative(from, import_node_path5.default.resolve(to)).split(import_node_path5.default.sep).join("/") || ".";
+  return import_node_path6.default.relative(from, import_node_path6.default.resolve(to)).split(import_node_path6.default.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,
@@ -2714,7 +3154,7 @@ function parseArtifactManifest(absolute, data) {
 }
 async function readOptional(file) {
   try {
-    return await (0, import_promises4.readFile)(file);
+    return await (0, import_promises5.readFile)(file);
   } catch (error) {
     if (isCode(error, "ENOENT")) return null;
     throw error;
@@ -2733,8 +3173,8 @@ function processIsAlive(pid) {
   }
 }
 function validTemporaryPath(candidate, destination, type) {
-  return import_node_path5.default.dirname(candidate) === import_node_path5.default.dirname(destination) && import_node_path5.default.basename(candidate).startsWith(
-    `.${import_node_path5.default.basename(destination)}.pixelkiln-${type}-`
+  return import_node_path6.default.dirname(candidate) === import_node_path6.default.dirname(destination) && import_node_path6.default.basename(candidate).startsWith(
+    `.${import_node_path6.default.basename(destination)}.pixelkiln-${type}-`
   );
 }
 function parseTransaction(journal, data) {
@@ -2750,14 +3190,14 @@ function parseTransaction(journal, data) {
   return raw;
 }
 async function removeTransactionFiles(journal) {
-  await (0, import_promises4.rm)(journal, { force: true });
-  await (0, import_promises4.rm)(transactionMarker(journal), { force: true });
+  await (0, import_promises5.rm)(journal, { force: true });
+  await (0, import_promises5.rm)(transactionMarker(journal), { force: true });
 }
 async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
-  const journal = import_node_path5.default.resolve(recoveryFile);
+  const journal = import_node_path6.default.resolve(recoveryFile);
   const bytes = await readOptional(journal);
   if (!bytes) {
-    await (0, import_promises4.rm)(transactionMarker(journal), { force: true });
+    await (0, import_promises5.rm)(transactionMarker(journal), { force: true });
     return;
   }
   if (activeTransactions.has(journal)) {
@@ -2770,7 +3210,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
     );
   }
   for (const entry of transaction.entries) {
-    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(import_node_path5.default.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
+    if (typeof entry.destination !== "string" || typeof entry.stage !== "string" || typeof entry.sha256 !== "string" || entry.backup !== void 0 && typeof entry.backup !== "string" || !allowedDestinations.has(import_node_path6.default.resolve(entry.destination)) || !validTemporaryPath(entry.stage, entry.destination, "stage") || entry.backup !== void 0 && !validTemporaryPath(entry.backup, entry.destination, "backup")) {
       throw new Error(
         `Refusing unsafe artifact recovery from ${journal}; its destinations or temporary paths do not match the current bundle.`
       );
@@ -2796,7 +3236,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
         }
         await remove2(entry.destination, errors);
         try {
-          await (0, import_promises4.rename)(entry.backup, entry.destination);
+          await (0, import_promises5.rename)(entry.backup, entry.destination);
         } catch (error) {
           errors.push(
             `could not restore ${entry.destination}; previous file remains at ${entry.backup}: ${message(error)}`
@@ -2816,7 +3256,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
   await removeTransactionFiles(journal);
 }
 function createArtifactBundleManifest(manifestPath, outputs, provenance) {
-  const root = import_node_path5.default.dirname(import_node_path5.default.resolve(manifestPath));
+  const root = import_node_path6.default.dirname(import_node_path6.default.resolve(manifestPath));
   const sources = provenance.sources.map((source) => ({
     ...source,
     path: portableRelative(root, source.path)
@@ -2824,7 +3264,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),
@@ -2846,11 +3286,11 @@ function withArtifactManifest(manifestPath, outputs, provenance) {
   ];
 }
 async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
-  const absoluteManifest = import_node_path5.default.resolve(manifestPath);
+  const absoluteManifest = import_node_path6.default.resolve(manifestPath);
   const recoveryFile = `${absoluteManifest}.transaction`;
   const allowedDestinations = /* @__PURE__ */ new Set([
     absoluteManifest,
-    ...outputs.map((output) => import_node_path5.default.resolve(output.path))
+    ...outputs.map((output) => import_node_path6.default.resolve(output.path))
   ]);
   await recoverArtifactTransaction(recoveryFile, allowedDestinations);
   const existingManifestBytes = await readOptional(absoluteManifest);
@@ -2868,13 +3308,13 @@ async function writeManagedArtifactBundle(manifestPath, outputs, provenance, opt
     }
   }
   if (!options.force) {
-    const root = import_node_path5.default.dirname(absoluteManifest);
+    const root = import_node_path6.default.dirname(absoluteManifest);
     const recorded = new Map(
-      previous?.outputs.map((output) => [import_node_path5.default.resolve(root, output.path), output.sha256]) ?? []
+      previous?.outputs.map((output) => [import_node_path6.default.resolve(root, output.path), output.sha256]) ?? []
     );
     const conflicts = [];
     for (const output of outputs) {
-      const destination = import_node_path5.default.resolve(output.path);
+      const destination = import_node_path6.default.resolve(output.path);
       const current = await readOptional(destination);
       if (!current || digest(current) === digest(output.data)) continue;
       const expected = recorded.get(destination);
@@ -2895,15 +3335,15 @@ Pass { force: true } (CLI: --force) to take ownership and replace the complete b
   );
 }
 async function verifyArtifactBundle(manifestPath) {
-  const absolute = import_node_path5.default.resolve(manifestPath);
-  const raw = parseArtifactManifest(absolute, await (0, import_promises4.readFile)(absolute, "utf8"));
-  const root = import_node_path5.default.dirname(absolute);
+  const absolute = import_node_path6.default.resolve(manifestPath);
+  const raw = parseArtifactManifest(absolute, await (0, import_promises5.readFile)(absolute, "utf8"));
+  const root = import_node_path6.default.dirname(absolute);
   const changedSources = [];
   const changedOutputs = [];
   for (const source of raw.sources) {
     let actual = null;
     try {
-      actual = digest(await (0, import_promises4.readFile)(import_node_path5.default.resolve(root, source.path)));
+      actual = digest(await (0, import_promises5.readFile)(import_node_path6.default.resolve(root, source.path)));
     } catch (error) {
       if (!isCode(error, "ENOENT")) throw error;
     }
@@ -2911,7 +3351,7 @@ async function verifyArtifactBundle(manifestPath) {
   }
   for (const output of raw.outputs) {
     try {
-      if (digest(await (0, import_promises4.readFile)(import_node_path5.default.resolve(root, output.path))) !== output.sha256) {
+      if (digest(await (0, import_promises5.readFile)(import_node_path6.default.resolve(root, output.path))) !== output.sha256) {
         changedOutputs.push(output.path);
       }
     } catch (error) {
@@ -2937,7 +3377,7 @@ function isCode(error, code) {
 }
 async function remove2(file, errors) {
   try {
-    await (0, import_promises4.rm)(file, { force: true });
+    await (0, import_promises5.rm)(file, { force: true });
   } catch (error) {
     errors?.push(`could not remove ${file}: ${message(error)}`);
   }
@@ -2950,7 +3390,7 @@ async function rollback(prepared) {
   for (const artifact of [...prepared].reverse()) {
     if (!artifact.backup || !artifact.backedUp) continue;
     try {
-      await (0, import_promises4.rename)(artifact.backup, artifact.destination);
+      await (0, import_promises5.rename)(artifact.backup, artifact.destination);
       artifact.backedUp = false;
     } catch (error) {
       errors.push(
@@ -2967,7 +3407,7 @@ async function writeArtifactBundle(files, options = {}) {
   if (!files.length) throw new Error("An artifact bundle must contain at least one file.");
   const normalized = files.map((file) => {
     if (!file.path.trim()) throw new Error("Artifact paths cannot be empty.");
-    return { destination: import_node_path5.default.resolve(file.path), data: Buffer.from(file.data) };
+    return { destination: import_node_path6.default.resolve(file.path), data: Buffer.from(file.data) };
   });
   const destinations = /* @__PURE__ */ new Set();
   for (const artifact of normalized) {
@@ -2983,7 +3423,7 @@ async function writeArtifactBundle(files, options = {}) {
   const unchanged = [];
   for (const artifact of normalized) {
     try {
-      const current = await (0, import_promises4.readFile)(artifact.destination);
+      const current = await (0, import_promises5.readFile)(artifact.destination);
       if (current.equals(artifact.data)) {
         unchanged.push(artifact.destination);
       } else {
@@ -2995,23 +3435,23 @@ async function writeArtifactBundle(files, options = {}) {
     }
   }
   if (!changed.length) return { changed: [], unchanged };
-  const token = (0, import_node_crypto4.randomUUID)();
+  const token = (0, import_node_crypto5.randomUUID)();
   for (const [index, artifact] of changed.entries()) {
-    const basename = import_node_path5.default.basename(artifact.destination);
-    artifact.stage = import_node_path5.default.join(
-      import_node_path5.default.dirname(artifact.destination),
+    const basename = import_node_path6.default.basename(artifact.destination);
+    artifact.stage = import_node_path6.default.join(
+      import_node_path6.default.dirname(artifact.destination),
       `.${basename}.pixelkiln-stage-${token}-${index}`
     );
     if (artifact.existed) {
-      artifact.backup = import_node_path5.default.join(
-        import_node_path5.default.dirname(artifact.destination),
+      artifact.backup = import_node_path6.default.join(
+        import_node_path6.default.dirname(artifact.destination),
         `.${basename}.pixelkiln-backup-${token}-${index}`
       );
     }
   }
-  const journal = options.recoveryFile ? import_node_path5.default.resolve(options.recoveryFile) : null;
+  const journal = options.recoveryFile ? import_node_path6.default.resolve(options.recoveryFile) : null;
   if (journal) {
-    await (0, import_promises4.mkdir)(import_node_path5.default.dirname(journal), { recursive: true });
+    await (0, import_promises5.mkdir)(import_node_path6.default.dirname(journal), { recursive: true });
     const transaction = {
       format: "pixelkiln-artifact-transaction",
       version: 1,
@@ -3025,7 +3465,7 @@ async function writeArtifactBundle(files, options = {}) {
       }))
     };
     try {
-      await (0, import_promises4.writeFile)(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
+      await (0, import_promises5.writeFile)(journal, JSON.stringify(transaction, null, 2) + "\n", { flag: "wx" });
       activeTransactions.add(journal);
     } catch (error) {
       throw new Error(
@@ -3036,9 +3476,9 @@ async function writeArtifactBundle(files, options = {}) {
   }
   try {
     for (const [index, artifact] of changed.entries()) {
-      await (0, import_promises4.mkdir)(import_node_path5.default.dirname(artifact.destination), { recursive: true });
+      await (0, import_promises5.mkdir)(import_node_path6.default.dirname(artifact.destination), { recursive: true });
       await options.beforeStage?.(artifact.destination, index);
-      await (0, import_promises4.writeFile)(artifact.stage, artifact.data, { flag: "wx" });
+      await (0, import_promises5.writeFile)(artifact.stage, artifact.data, { flag: "wx" });
     }
   } catch (error) {
     const cleanupErrors2 = await rollback(changed);
@@ -3051,17 +3491,17 @@ async function writeArtifactBundle(files, options = {}) {
   try {
     for (const artifact of changed) {
       if (!artifact.existed) continue;
-      await (0, import_promises4.rename)(artifact.destination, artifact.backup);
+      await (0, import_promises5.rename)(artifact.destination, artifact.backup);
       artifact.backedUp = true;
     }
     for (const [index, artifact] of changed.entries()) {
       await options.beforePromote?.(artifact.destination, index);
-      await (0, import_promises4.rename)(artifact.stage, artifact.destination);
+      await (0, import_promises5.rename)(artifact.stage, artifact.destination);
       artifact.stage = void 0;
       artifact.promoted = true;
     }
     if (journal) {
-      await (0, import_promises4.writeFile)(transactionMarker(journal), `${token}
+      await (0, import_promises5.writeFile)(transactionMarker(journal), `${token}
 `, { flag: "wx" });
       durableCommit = true;
       await options.afterCommit?.();
@@ -3105,7 +3545,7 @@ async function writeArtifactBundle(files, options = {}) {
 
 // src/pipeline/plan.ts
 var import_node_fs4 = require("fs");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 async function anyOutputModified(entry, spec) {
   for (let index = 0; index < entry.outputs.length; index++) {
     const output = entry.outputs[index];
@@ -3124,7 +3564,7 @@ async function buildPlan(specs, lock, opts = {}) {
       state = "missing";
       reason = "--force";
     } else if (!entry && spec.source) {
-      if ((0, import_node_fs4.existsSync)(import_node_path6.default.resolve(spec.root, spec.source))) {
+      if ((0, import_node_fs4.existsSync)(import_node_path7.default.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -3190,9 +3630,9 @@ function summarize(plan) {
 }
 
 // src/pipeline/audit.ts
-var import_promises5 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 var import_node_fs5 = require("fs");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 function colorDistance(a, b) {
   const rmean = (a.r + b.r) / 2;
   const dr = a.r - b.r;
@@ -3242,7 +3682,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
         continue;
       }
       try {
-        const png = decodePng(await (0, import_promises5.readFile)(output.absolutePath));
+        const png = decodePng(await (0, import_promises6.readFile)(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -3266,10 +3706,10 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = import_node_path7.default.resolve(loaded.root, img.path);
+    const abs = import_node_path8.default.resolve(loaded.root, img.path);
     if (!(0, import_node_fs5.existsSync)(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await (0, import_promises5.readFile)(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await (0, import_promises6.readFile)(abs)), 12));
     } catch {
     }
   }
@@ -3346,13 +3786,13 @@ function hex(c) {
 
 // src/pipeline/cache-health.ts
 var import_node_fs7 = require("fs");
-var import_promises7 = require("fs/promises");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_promises8 = require("fs/promises");
+var import_node_path10 = __toESM(require("path"), 1);
 
 // src/cache.ts
-var import_promises6 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 var import_node_fs6 = require("fs");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 var import_zod3 = require("zod");
 var HashCacheSchema = import_zod3.z.object({
   version: import_zod3.z.literal(1),
@@ -3366,10 +3806,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path17) {
-  if (!(0, import_node_fs6.existsSync)(path17)) return { version: 1, hashes: {} };
+async function loadCache(path18) {
+  if (!(0, import_node_fs6.existsSync)(path18)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises6.readFile)(path17, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await (0, import_promises7.readFile)(path18, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -3381,20 +3821,20 @@ async function loadCache(path17) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path17, cache) {
+async function saveCache(path18, cache) {
   const sorted = {};
   for (const key of Object.keys(cache.hashes).sort()) {
     const hash = cache.hashes[key];
     if (!isSha256Hash(hash)) throw new Error(`Refusing to cache invalid SHA-256 for ${key}`);
     sorted[key] = hash;
   }
-  await (0, import_promises6.mkdir)(import_node_path8.default.dirname(import_node_path8.default.resolve(path17)), { recursive: true });
-  const tmp = `${path17}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await (0, import_promises7.mkdir)(import_node_path9.default.dirname(import_node_path9.default.resolve(path18)), { recursive: true });
+  const tmp = `${path18}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises6.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await (0, import_promises6.rename)(tmp, path17);
+    await (0, import_promises7.writeFile)(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
+    await (0, import_promises7.rename)(tmp, path18);
   } finally {
-    await (0, import_promises6.rm)(tmp, { force: true });
+    await (0, import_promises7.rm)(tmp, { force: true });
   }
 }
 function pruneCache(cache, liveIds) {
@@ -3415,10 +3855,10 @@ function cachePathFor(lockPath) {
 // src/pipeline/cache-health.ts
 async function inspectCaches(lock, lockPath, options = {}) {
   if (options.prune && !(0, import_node_fs7.existsSync)(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${import_node_path9.default.resolve(lockPath)}`);
+    throw new Error(`Refusing to prune without an existing lockfile at ${import_node_path10.default.resolve(lockPath)}`);
   }
-  const contentDir = import_node_path9.default.resolve(import_node_path9.default.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = import_node_path9.default.resolve(cachePathFor(lockPath));
+  const contentDir = import_node_path10.default.resolve(import_node_path10.default.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = import_node_path10.default.resolve(cachePathFor(lockPath));
   const referenced = new Set(
     Object.values(lock.entries).flatMap((entry) => entry.outputs.map((output) => output.sha256))
   );
@@ -3432,7 +3872,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await (0, import_promises7.rm)(import_node_path9.default.join(contentDir, name), { force: true });
+        await (0, import_promises8.rm)(import_node_path10.default.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -3441,7 +3881,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
       await saveCache(remotePath, { version: 1, hashes: {} });
       removed.resetRemoteHashCache = true;
     } else if (remoteHashes.invalidIds.length) {
-      const cache = parseCache(JSON.parse(await (0, import_promises7.readFile)(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await (0, import_promises8.readFile)(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -3473,19 +3913,19 @@ async function inspectContentCache(contentDir, referenced) {
     return report;
   }
   const present = /* @__PURE__ */ new Set();
-  const entries = await (0, import_promises7.readdir)(contentDir, { withFileTypes: true });
+  const entries = await (0, import_promises8.readdir)(contentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isFile()) {
       report.invalid.push({ name: entry.name, reason: "not a regular file" });
       continue;
     }
     report.files++;
-    const file = import_node_path9.default.join(contentDir, entry.name);
+    const file = import_node_path10.default.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await (0, import_promises7.readFile)(file);
+      bytes = await (0, import_promises8.readFile)(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -3532,7 +3972,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await (0, import_promises7.readFile)(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await (0, import_promises8.readFile)(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -3548,18 +3988,18 @@ async function inspectRemoteHashCache(remotePath) {
 
 // src/pipeline/pack.ts
 var import_node_fs8 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 function resolvePackInputs(raw, inputsFilePath) {
   if (!Array.isArray(raw) || !raw.length) {
     throw new Error("--inputs must be a non-empty JSON array of { id, path }");
   }
-  const baseDir = import_node_path10.default.dirname(import_node_path10.default.resolve(inputsFilePath));
+  const baseDir = import_node_path11.default.dirname(import_node_path11.default.resolve(inputsFilePath));
   return raw.map((entry, i) => {
     const e = entry;
     if (typeof e.id !== "string" || typeof e.path !== "string") {
       throw new Error(`--inputs[${i}] needs string "id" and "path"`);
     }
-    return { id: e.id, path: import_node_path10.default.resolve(baseDir, e.path) };
+    return { id: e.id, path: import_node_path11.default.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -3756,7 +4196,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     const cell = cells[id];
     const source = sources[id];
     if (source) {
-      placements.push({ id, path: import_node_path10.default.resolve(manifestDir, source), cell });
+      placements.push({ id, path: import_node_path11.default.resolve(manifestDir, source), cell });
       continue;
     }
     const entry = lock.entries[`${styleId}/${id}`];
@@ -3780,7 +4220,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
       `Nothing to mount for style "${styleId}": ${ids.length} asset(s) declare a cell, but none has generated output or a \`source\`. Run \`pixelkiln gen --style ${styleId}\`, or point each at a file.${detail}`
     );
   }
-  const basePng = mount.base ? (0, import_node_fs8.readFileSync)(import_node_path10.default.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? (0, import_node_fs8.readFileSync)(import_node_path11.default.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -3790,7 +4230,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: import_node_path10.default.resolve(manifestDir, mount.base),
+      path: import_node_path11.default.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -4202,7 +4642,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++;
           log(`  review  ${key} (${state.candidateUrls.length} candidates)`);
         } else if (state.status === "ready") {
@@ -4235,15 +4679,15 @@ async function poll(provider, lock, lockPath, opts = {}) {
 
 // src/pipeline/fetch.ts
 var import_node_fs9 = require("fs");
-var import_promises8 = require("fs/promises");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_promises9 = require("fs/promises");
+var import_node_path12 = __toESM(require("path"), 1);
 async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   const log = 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 : import_node_path11.default.resolve(opts.cacheDir ?? import_node_path11.default.join(import_node_path11.default.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : import_node_path12.default.resolve(opts.cacheDir ?? import_node_path12.default.join(import_node_path12.default.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;
@@ -4295,7 +4739,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             if (cacheDir) {
               await cacheMedia(
                 cacheDir,
-                await (0, import_promises8.readFile)(target),
+                await (0, import_promises9.readFile)(target),
                 recorded.mediaType ?? MediaType.PNG,
                 recorded.sha256
               );
@@ -4306,7 +4750,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) {
-            log(`  cached  ${import_node_path11.default.relative(process.cwd(), target)}`);
+            log(`  cached  ${import_node_path12.default.relative(process.cwd(), target)}`);
           } else {
             if (!source.url) {
               throw new Error(`no source URL or cached bytes remain for ${source.role ?? "asset"}`);
@@ -4324,9 +4768,9 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             );
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await (0, import_promises8.mkdir)(import_node_path11.default.dirname(target), { recursive: true });
+          await (0, import_promises9.mkdir)(import_node_path12.default.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
-          await (0, import_promises8.writeFile)(tmp, buf);
+          await (0, import_promises9.writeFile)(tmp, buf);
           outputs.push({
             path: portableOutputPath(target, spec.root),
             sha256: sha256(buf),
@@ -4335,8 +4779,8 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           });
           upsert(lock, key, { outputs: mergeOutputs(entry.outputs, outputs) });
           await saveLock(lockPath, lock);
-          await (0, import_promises8.rename)(tmp, target);
-          log(`  wrote   ${import_node_path11.default.relative(process.cwd(), target)}`);
+          await (0, import_promises9.rename)(tmp, target);
+          log(`  wrote   ${import_node_path12.default.relative(process.cwd(), target)}`);
         }
         upsert(lock, key, {
           status: "downloaded",
@@ -4369,10 +4813,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = import_node_path11.default.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = import_node_path12.default.join(cacheDir, cacheFileName(hash, mediaType));
   if (!(0, import_node_fs9.existsSync)(file)) return null;
   try {
-    const buf = await (0, import_promises8.readFile)(file);
+    const buf = await (0, import_promises9.readFile)(file);
     if (sha256(buf) !== hash) return null;
     validateMedia(buf, mediaType);
     return buf;
@@ -4383,17 +4827,17 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = import_node_path11.default.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = import_node_path12.default.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
-  await (0, import_promises8.mkdir)(cacheDir, { recursive: true });
+  await (0, import_promises9.mkdir)(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  await (0, import_promises8.writeFile)(tmp, buf);
+  await (0, import_promises9.writeFile)(tmp, buf);
   try {
-    await (0, import_promises8.rename)(tmp, file);
+    await (0, import_promises9.rename)(tmp, file);
   } catch (err) {
     if (!(0, import_node_fs9.existsSync)(file)) throw err;
   } finally {
-    await (0, import_promises8.rm)(tmp, { force: true });
+    await (0, import_promises9.rm)(tmp, { force: true });
   }
 }
 function mergeOutputs(previous, current) {
@@ -4425,8 +4869,8 @@ async function pushTags(provider, specs, lock, opts = {}) {
 
 // src/pipeline/doctor.ts
 var import_node_fs10 = require("fs");
-var import_promises9 = require("fs/promises");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_promises10 = require("fs/promises");
+var import_node_path13 = __toESM(require("path"), 1);
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message2) => checks.push({ id, level, message: message2 });
@@ -4436,12 +4880,12 @@ 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) => import_node_path12.default.dirname(s.outFile)))];
+  const dirs = [...new Set(specs.map((s) => import_node_path13.default.dirname(s.outFile)))];
   const unwritable = [];
   for (const dir of dirs) {
     const ancestor = await nearestExistingDirectory(dir);
     try {
-      await (0, import_promises9.access)(ancestor, import_node_fs10.constants.W_OK);
+      await (0, import_promises10.access)(ancestor, import_node_fs10.constants.W_OK);
     } catch {
       unwritable.push(dir);
     }
@@ -4458,7 +4902,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
     for (let index = 0; index < entry.outputs.length; index++) {
       const output = entry.outputs[index];
       const spec = specByKey.get(key);
-      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, import_node_path12.default.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, import_node_path13.default.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -4473,7 +4917,7 @@ async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   } else {
     add("lock-outputs", "ok", `${outputOwners.size} recorded output path(s) are uniquely owned`);
   }
-  const cacheDir = import_node_path12.default.join(import_node_path12.default.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = import_node_path13.default.join(import_node_path13.default.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -4489,7 +4933,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 = import_node_path12.default.join(
+      const cached = import_node_path13.default.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
@@ -4524,8 +4968,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 {
@@ -4541,10 +4992,10 @@ async function nearestExistingDirectory(start) {
   let current = start;
   for (; ; ) {
     try {
-      if ((await (0, import_promises9.stat)(current)).isDirectory()) return current;
+      if ((await (0, import_promises10.stat)(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = import_node_path12.default.dirname(current);
+    const parent = import_node_path13.default.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
@@ -4552,8 +5003,8 @@ async function nearestExistingDirectory(start) {
 
 // src/pipeline/adopt.ts
 var import_node_fs11 = require("fs");
-var import_promises10 = require("fs/promises");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_promises11 = require("fs/promises");
+var import_node_path14 = __toESM(require("path"), 1);
 async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const log = opts.onProgress ?? (() => {
   });
@@ -4568,7 +5019,7 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
-    const bytes = await (0, import_promises10.readFile)(spec.outFile);
+    const bytes = await (0, import_promises11.readFile)(spec.outFile);
     try {
       decodePng(bytes);
     } catch (err) {
@@ -5044,9 +5495,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/init.ts
-var import_promises11 = require("fs/promises");
+var import_promises12 = require("fs/promises");
 var import_node_fs12 = require("fs");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -5059,8 +5510,8 @@ function slugify(value) {
 }
 async function walk(dir, exclude) {
   const out = [];
-  for (const entry of await (0, import_promises11.readdir)(dir, { withFileTypes: true })) {
-    const full = import_node_path14.default.join(dir, entry.name);
+  for (const entry of await (0, import_promises12.readdir)(dir, { withFileTypes: true })) {
+    const full = import_node_path15.default.join(dir, entry.name);
     if (exclude.some((x) => full.includes(x))) continue;
     if (entry.isDirectory()) out.push(...await walk(full, exclude));
     else if (entry.name.toLowerCase().endsWith(".png")) out.push(full);
@@ -5074,14 +5525,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await (0, import_promises11.readFile)(file));
+    const size = pngSize(await (0, import_promises12.readFile)(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = import_node_path14.default.relative(root, file);
-    const category = import_node_path14.default.dirname(rel) === "." ? "" : import_node_path14.default.dirname(rel);
-    let id = slugify(import_node_path14.default.basename(rel));
+    const rel = import_node_path15.default.relative(root, file);
+    const category = import_node_path15.default.dirname(rel) === "." ? "" : import_node_path15.default.dirname(rel);
+    let id = slugify(import_node_path15.default.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -5137,16 +5588,16 @@ function mode(values) {
 }
 
 // src/pipeline/salvage.ts
-var import_promises12 = require("fs/promises");
+var import_promises13 = require("fs/promises");
 var import_node_fs13 = require("fs");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
 async function loadClaims(lockPaths) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
     if (!(0, import_node_fs13.existsSync)(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await (0, import_promises12.readFile)(p, "utf8")));
+      parsed = parseLock(JSON.parse(await (0, import_promises13.readFile)(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -5193,20 +5644,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = import_node_path15.default.resolve(ownManifestPath);
+  const own = import_node_path16.default.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => import_node_path15.default.join(import_node_path15.default.dirname(import_node_path15.default.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => import_node_path16.default.join(import_node_path16.default.dirname(import_node_path16.default.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (import_node_path15.default.resolve(siblingManifestPath) === own) continue;
+    if (import_node_path16.default.resolve(siblingManifestPath) === own) continue;
     if (!(0, import_node_fs13.existsSync)(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: import_node_path15.default.basename(import_node_path15.default.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: import_node_path16.default.basename(import_node_path16.default.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -5322,8 +5773,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-var import_promises13 = require("fs/promises");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_promises14 = require("fs/promises");
+var import_node_path17 = __toESM(require("path"), 1);
 
 // src/pick/salvage-sheet.ts
 var escapeHtml2 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -5488,7 +5939,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: import_node_path16.default.relative(process.cwd(), ctx.importDir) || "."
+    importDir: import_node_path17.default.relative(process.cwd(), ctx.importDir) || "."
   });
   const byId = new Map(orphans.map((o) => [o.id, o]));
   const existingTags = new Map(orphans.map((o) => [o.id, o.tags]));
@@ -5517,10 +5968,10 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
             if (!buf.subarray(0, 8).equals(PNG_SIGNATURE2)) throw new Error("not a PNG");
             decodePng(buf);
             const assetId = idFromPrompt(orphan.prompt, taken);
-            const rel = import_node_path16.default.join("_salvaged", `${assetId}.png`);
-            const outFile = import_node_path16.default.resolve(ctx.importDir, rel);
-            await (0, import_promises13.mkdir)(import_node_path16.default.dirname(outFile), { recursive: true });
-            await (0, import_promises13.writeFile)(outFile, buf);
+            const rel = import_node_path17.default.join("_salvaged", `${assetId}.png`);
+            const outFile = import_node_path17.default.resolve(ctx.importDir, rel);
+            await (0, import_promises14.mkdir)(import_node_path17.default.dirname(outFile), { recursive: true });
+            await (0, import_promises14.writeFile)(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -5546,7 +5997,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               error: null,
               sourceUrl: orphan.previewUrl,
               outputs: [{
-                path: portableOutputPath(outFile, import_node_path16.default.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, import_node_path17.default.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -5570,9 +6021,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log });
-      const raw = JSON.parse(await (0, import_promises13.readFile)(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await (0, import_promises14.readFile)(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await (0, import_promises13.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await (0, import_promises14.writeFile)(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       return result;
     }
@@ -5580,9 +6031,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 }
 
 // src/workspace.ts
-var import_promises14 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var import_node_fs14 = require("fs");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 var import_zod4 = require("zod");
 var WorkspaceProjectSchema = import_zod4.z.object({
   id: import_zod4.z.string().min(1),
@@ -5610,7 +6061,7 @@ async function loadWorkspace(workspacePath) {
   if (!(0, import_node_fs14.existsSync)(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await (0, import_promises14.readFile)(workspacePath, "utf8"));
+    raw = JSON.parse(await (0, import_promises15.readFile)(workspacePath, "utf8"));
   } catch (err) {
     throw new Error(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -5624,22 +6075,22 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await (0, import_promises14.mkdir)(import_node_path17.default.dirname(import_node_path17.default.resolve(workspacePath)), { recursive: true });
+  await (0, import_promises15.mkdir)(import_node_path18.default.dirname(import_node_path18.default.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await (0, import_promises14.writeFile)(tmp, JSON.stringify(sorted, null, 2) + "\n");
-    await (0, import_promises14.rename)(tmp, workspacePath);
+    await (0, import_promises15.writeFile)(tmp, JSON.stringify(sorted, null, 2) + "\n");
+    await (0, import_promises15.rename)(tmp, workspacePath);
   } finally {
-    await (0, import_promises14.rm)(tmp, { force: true });
+    await (0, import_promises15.rm)(tmp, { force: true });
   }
 }
 function toPortablePath(dir, absolute) {
-  return import_node_path17.default.relative(dir, absolute).split(import_node_path17.default.sep).join("/");
+  return import_node_path18.default.relative(dir, absolute).split(import_node_path18.default.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: import_node_path17.default.resolve(dir, project.manifest.split("/").join(import_node_path17.default.sep)),
-    lockPath: import_node_path17.default.resolve(dir, project.lock.split("/").join(import_node_path17.default.sep))
+    manifestPath: import_node_path18.default.resolve(dir, project.manifest.split("/").join(import_node_path18.default.sep)),
+    lockPath: import_node_path18.default.resolve(dir, project.lock.split("/").join(import_node_path18.default.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -5652,7 +6103,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 (import_node_path17.default.isAbsolute(project.manifest) || import_node_path17.default.isAbsolute(project.lock)) {
+    if (import_node_path18.default.isAbsolute(project.manifest) || import_node_path18.default.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
@@ -5808,6 +6259,7 @@ async function workspaceStatus(ws, dir) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AssetSchema,
+  ComfyUIProvider,
   DEFAULT_RATE_LIMIT,
   FAKE_PNG,
   FakeProvider,