pixelkiln 0.6.0 → 0.8.0

package/dist/index.js

@@ -40,8 +40,8 @@ var StyleSchema = 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: z.number().int().min(32).max(256).optional(),
+  /** Square edge length. The active provider owns its exact limit. */
+  size: z.number().int().min(16).max(8192).optional(),
   view: z.string().optional(),
   /** Appended to every asset prompt in this style. Where the look is defined. */
   promptSuffix: z.string().default(""),
@@ -157,8 +157,8 @@ var AssetSchema = z.object({
   /** Subdirectory under the style's outDir. Optional. */
   category: z.string().optional(),
   /** Overrides the style default. `map` generator only. */
-  width: z.number().int().min(16).max(400).optional(),
-  height: z.number().int().min(16).max(400).optional(),
+  width: z.number().int().min(16).max(8192).optional(),
+  height: z.number().int().min(16).max(8192).optional(),
   /** Overrides the style default. `1dir` generator only. */
   size: z.number().int().min(32).max(256).optional(),
   /** Explicit output path relative to outDir. Media-aware providers may replace its extension. */
@@ -416,11 +416,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: {
@@ -432,24 +432,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() {
@@ -1213,6 +1213,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, [
@@ -1489,9 +1495,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",
@@ -1761,8 +1767,470 @@ function retroError(value) {
   return JSON.stringify(value);
 }
 
-// src/providers/fake.ts
+// src/providers/comfyui.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import path2 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(path18) {
+  return sha256(await 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: randomUUID2() })
+    });
+    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 = 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/fake.ts
+import { createHash as createHash2 } from "crypto";
 var FAKE_PNG = Buffer.from(
   "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
   "base64"
@@ -1846,7 +2314,7 @@ var FakeProvider = class {
   }
   async download(url) {
     if (!url.startsWith("fake://")) throw new Error(`fake provider cannot download ${url}`);
-    const salt = createHash("sha256").update(url).digest();
+    const salt = createHash2("sha256").update(url).digest();
     return Buffer.concat([FAKE_PNG, salt.subarray(0, 4)]);
   }
   async balance() {
@@ -1945,56 +2413,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 existsSync2 } from "fs";
-import path2 from "path";
-
-// src/hash.ts
-import { createHash as createHash2 } from "crypto";
-import { readFile } from "fs/promises";
-function sha256(data) {
-  return createHash2("sha256").update(data).digest("hex");
-}
-async function sha256File(path17) {
-  return sha256(await 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
+import path3 from "path";
 async function loadManifest(manifestPath) {
-  const abs = path2.resolve(manifestPath);
+  const abs = path3.resolve(manifestPath);
   if (!existsSync2(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:
@@ -2016,7 +2451,7 @@ ${issues}`);
     throw new Error(`Manifest at ${abs} is invalid:
 ${unknownReferences.map((i) => `  ${i}`).join("\n")}`);
   }
-  return { manifest: parsed.data, root: path2.dirname(abs), path: abs };
+  return { manifest: parsed.data, root: path3.dirname(abs), path: abs };
 }
 async function resolveSpecs(loaded, filter) {
   const { manifest, root } = loaded;
@@ -2039,11 +2474,11 @@ async function resolveSpecs(loaded, filter) {
   }
   const styleImageCache = /* @__PURE__ */ new Map();
   async function loadStyleImage(rel) {
-    const abs = path2.resolve(root, rel);
+    const abs = path3.resolve(root, rel);
     let hit = styleImageCache.get(abs);
     if (!hit) {
       if (!existsSync2(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) {
@@ -2056,6 +2491,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) {
@@ -2088,15 +2527,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 ?? path2.join(asset.category ?? "", `${assetId}.png`);
-      const outFile = path2.resolve(root, style.outDir, relFile);
+      const relFile = asset.file ?? path3.join(asset.category ?? "", `${assetId}.png`);
+      const outFile = path3.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,
@@ -2134,10 +2573,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(path2.resolve(root, image.path));
+        const hit = styleImageCache.get(path3.resolve(root, image.path));
         return { base64: hit.base64, width: hit.width, height: hit.height, format: hit.format };
       });
       activeProvider.validate?.(resolved, resolvedImages);
@@ -2164,8 +2603,8 @@ async function resolveStyleImages(loaded, styleId) {
   if (!style) throw new Error(`Unknown style "${styleId}"`);
   const out = [];
   for (const img of style.styleImages) {
-    const file = path2.resolve(loaded.root, img.path);
-    const buf = await readFile2(file);
+    const file = path3.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) {
@@ -2208,13 +2647,13 @@ function imageMetadata(buf) {
 }
 
 // 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 existsSync3 } from "fs";
-import path3 from "path";
+import path4 from "path";
 async function loadLock(lockPath) {
   if (!existsSync3(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:
@@ -2226,7 +2665,7 @@ var saveQueues = /* @__PURE__ */ new Map();
 var dirtyPatches = /* @__PURE__ */ new WeakMap();
 var dirtyDeletes = /* @__PURE__ */ new WeakMap();
 function saveLock(lockPath, lock) {
-  const queueKey = path3.resolve(lockPath);
+  const queueKey = path4.resolve(lockPath);
   const previous = saveQueues.get(queueKey) ?? Promise.resolve();
   const next = previous.catch(() => {
   }).then(() => writeLockNow(lockPath, lock));
@@ -2238,7 +2677,7 @@ function saveLock(lockPath, lock) {
   return next;
 }
 async function writeLockNow(lockPath, lock) {
-  await mkdir(path3.dirname(path3.resolve(lockPath)), { recursive: true });
+  await mkdir(path4.dirname(path4.resolve(lockPath)), { recursive: true });
   const release = await acquireFileLock(lockPath);
   try {
     await writeLockWhileHeld(lockPath, lock);
@@ -2250,7 +2689,7 @@ async function writeLockWhileHeld(file, lock) {
   let disk = { version: 2, entries: {} };
   if (existsSync3(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)}`
@@ -2381,21 +2820,21 @@ function totalSpend(lock, unit = "generations") {
 }
 
 // src/outputs.ts
-import path4 from "path";
+import path5 from "path";
 function portableOutputPath(file, manifestDir) {
-  const root = path4.resolve(manifestDir);
-  const absolute = path4.isAbsolute(file) ? path4.normalize(file) : path4.resolve(root, file);
-  const relative = path4.relative(root, absolute);
-  const value = path4.isAbsolute(relative) ? absolute : relative;
-  return value.split(path4.sep).join("/");
+  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("/");
 }
 function resolveOutputPath(recordedPath, manifestDir) {
-  if (path4.isAbsolute(recordedPath)) return path4.normalize(recordedPath);
-  if (path4.win32.isAbsolute(recordedPath)) return recordedPath;
-  return path4.resolve(manifestDir, recordedPath.split(/[\\/]/).join(path4.sep));
+  if (path5.isAbsolute(recordedPath)) return path5.normalize(recordedPath);
+  if (path5.win32.isAbsolute(recordedPath)) return recordedPath;
+  return path5.resolve(manifestDir, recordedPath.split(/[\\/]/).join(path5.sep));
 }
 function expectedOutputPath(spec, role, index, total, mediaType) {
-  const originalExt = path4.extname(spec.outFile);
+  const originalExt = path5.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}`;
@@ -2484,15 +2923,15 @@ function resolveSpecOutputs(spec, lock, manifestDir) {
     id: spec.assetId,
     index: 0,
     path: spec.outFile,
-    absolutePath: path4.resolve(spec.outFile),
+    absolutePath: path5.resolve(spec.outFile),
     sha256: ""
   }];
 }
 
 // src/artifacts.ts
-import path5 from "path";
-import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir2, readFile as readFile4, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import path6 from "path";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir2, readFile as readFile5, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 var activeTransactions = /* @__PURE__ */ new Set();
 function message(error) {
   return error instanceof Error ? error.message : String(error);
@@ -2501,27 +2940,27 @@ function digest(data) {
   return createHash3("sha256").update(data).digest("hex");
 }
 function portableRelative(from, to) {
-  return path5.relative(from, path5.resolve(to)).split(path5.sep).join("/") || ".";
+  return path6.relative(from, path6.resolve(to)).split(path6.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,
@@ -2552,7 +2991,7 @@ function parseArtifactManifest(absolute, data) {
 }
 async function readOptional(file) {
   try {
-    return await readFile4(file);
+    return await readFile5(file);
   } catch (error) {
     if (isCode(error, "ENOENT")) return null;
     throw error;
@@ -2571,8 +3010,8 @@ function processIsAlive(pid) {
   }
 }
 function validTemporaryPath(candidate, destination, type) {
-  return path5.dirname(candidate) === path5.dirname(destination) && path5.basename(candidate).startsWith(
-    `.${path5.basename(destination)}.pixelkiln-${type}-`
+  return path6.dirname(candidate) === path6.dirname(destination) && path6.basename(candidate).startsWith(
+    `.${path6.basename(destination)}.pixelkiln-${type}-`
   );
 }
 function parseTransaction(journal, data) {
@@ -2592,7 +3031,7 @@ async function removeTransactionFiles(journal) {
   await rm2(transactionMarker(journal), { force: true });
 }
 async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
-  const journal = path5.resolve(recoveryFile);
+  const journal = path6.resolve(recoveryFile);
   const bytes = await readOptional(journal);
   if (!bytes) {
     await rm2(transactionMarker(journal), { force: true });
@@ -2608,7 +3047,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(path5.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(path6.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.`
       );
@@ -2654,7 +3093,7 @@ async function recoverArtifactTransaction(recoveryFile, allowedDestinations) {
   await removeTransactionFiles(journal);
 }
 function createArtifactBundleManifest(manifestPath, outputs, provenance) {
-  const root = path5.dirname(path5.resolve(manifestPath));
+  const root = path6.dirname(path6.resolve(manifestPath));
   const sources = provenance.sources.map((source) => ({
     ...source,
     path: portableRelative(root, source.path)
@@ -2662,7 +3101,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),
@@ -2684,11 +3123,11 @@ function withArtifactManifest(manifestPath, outputs, provenance) {
   ];
 }
 async function writeManagedArtifactBundle(manifestPath, outputs, provenance, options = {}) {
-  const absoluteManifest = path5.resolve(manifestPath);
+  const absoluteManifest = path6.resolve(manifestPath);
   const recoveryFile = `${absoluteManifest}.transaction`;
   const allowedDestinations = /* @__PURE__ */ new Set([
     absoluteManifest,
-    ...outputs.map((output) => path5.resolve(output.path))
+    ...outputs.map((output) => path6.resolve(output.path))
   ]);
   await recoverArtifactTransaction(recoveryFile, allowedDestinations);
   const existingManifestBytes = await readOptional(absoluteManifest);
@@ -2706,13 +3145,13 @@ async function writeManagedArtifactBundle(manifestPath, outputs, provenance, opt
     }
   }
   if (!options.force) {
-    const root = path5.dirname(absoluteManifest);
+    const root = path6.dirname(absoluteManifest);
     const recorded = new Map(
-      previous?.outputs.map((output) => [path5.resolve(root, output.path), output.sha256]) ?? []
+      previous?.outputs.map((output) => [path6.resolve(root, output.path), output.sha256]) ?? []
     );
     const conflicts = [];
     for (const output of outputs) {
-      const destination = path5.resolve(output.path);
+      const destination = path6.resolve(output.path);
       const current = await readOptional(destination);
       if (!current || digest(current) === digest(output.data)) continue;
       const expected = recorded.get(destination);
@@ -2733,15 +3172,15 @@ Pass { force: true } (CLI: --force) to take ownership and replace the complete b
   );
 }
 async function verifyArtifactBundle(manifestPath) {
-  const absolute = path5.resolve(manifestPath);
-  const raw = parseArtifactManifest(absolute, await readFile4(absolute, "utf8"));
-  const root = path5.dirname(absolute);
+  const absolute = path6.resolve(manifestPath);
+  const raw = parseArtifactManifest(absolute, await readFile5(absolute, "utf8"));
+  const root = path6.dirname(absolute);
   const changedSources = [];
   const changedOutputs = [];
   for (const source of raw.sources) {
     let actual = null;
     try {
-      actual = digest(await readFile4(path5.resolve(root, source.path)));
+      actual = digest(await readFile5(path6.resolve(root, source.path)));
     } catch (error) {
       if (!isCode(error, "ENOENT")) throw error;
     }
@@ -2749,7 +3188,7 @@ async function verifyArtifactBundle(manifestPath) {
   }
   for (const output of raw.outputs) {
     try {
-      if (digest(await readFile4(path5.resolve(root, output.path))) !== output.sha256) {
+      if (digest(await readFile5(path6.resolve(root, output.path))) !== output.sha256) {
         changedOutputs.push(output.path);
       }
     } catch (error) {
@@ -2805,7 +3244,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: path5.resolve(file.path), data: Buffer.from(file.data) };
+    return { destination: path6.resolve(file.path), data: Buffer.from(file.data) };
   });
   const destinations = /* @__PURE__ */ new Set();
   for (const artifact of normalized) {
@@ -2821,7 +3260,7 @@ async function writeArtifactBundle(files, options = {}) {
   const unchanged = [];
   for (const artifact of normalized) {
     try {
-      const current = await readFile4(artifact.destination);
+      const current = await readFile5(artifact.destination);
       if (current.equals(artifact.data)) {
         unchanged.push(artifact.destination);
       } else {
@@ -2833,23 +3272,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 = path5.basename(artifact.destination);
-    artifact.stage = path5.join(
-      path5.dirname(artifact.destination),
+    const basename = path6.basename(artifact.destination);
+    artifact.stage = path6.join(
+      path6.dirname(artifact.destination),
       `.${basename}.pixelkiln-stage-${token}-${index}`
     );
     if (artifact.existed) {
-      artifact.backup = path5.join(
-        path5.dirname(artifact.destination),
+      artifact.backup = path6.join(
+        path6.dirname(artifact.destination),
         `.${basename}.pixelkiln-backup-${token}-${index}`
       );
     }
   }
-  const journal = options.recoveryFile ? path5.resolve(options.recoveryFile) : null;
+  const journal = options.recoveryFile ? path6.resolve(options.recoveryFile) : null;
   if (journal) {
-    await mkdir2(path5.dirname(journal), { recursive: true });
+    await mkdir2(path6.dirname(journal), { recursive: true });
     const transaction = {
       format: "pixelkiln-artifact-transaction",
       version: 1,
@@ -2874,7 +3313,7 @@ async function writeArtifactBundle(files, options = {}) {
   }
   try {
     for (const [index, artifact] of changed.entries()) {
-      await mkdir2(path5.dirname(artifact.destination), { recursive: true });
+      await mkdir2(path6.dirname(artifact.destination), { recursive: true });
       await options.beforeStage?.(artifact.destination, index);
       await writeFile2(artifact.stage, artifact.data, { flag: "wx" });
     }
@@ -2943,7 +3382,7 @@ async function writeArtifactBundle(files, options = {}) {
 
 // src/pipeline/plan.ts
 import { existsSync as existsSync4 } from "fs";
-import path6 from "path";
+import path7 from "path";
 async function anyOutputModified(entry, spec) {
   for (let index = 0; index < entry.outputs.length; index++) {
     const output = entry.outputs[index];
@@ -2962,7 +3401,7 @@ async function buildPlan(specs, lock, opts = {}) {
       state = "missing";
       reason = "--force";
     } else if (!entry && spec.source) {
-      if (existsSync4(path6.resolve(spec.root, spec.source))) {
+      if (existsSync4(path7.resolve(spec.root, spec.source))) {
         state = "ok";
         reason = `placed from ${spec.source}; not generated`;
       } else {
@@ -3028,9 +3467,9 @@ function summarize(plan) {
 }
 
 // src/pipeline/audit.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import path7 from "path";
+import path8 from "path";
 function colorDistance(a, b) {
   const rmean = (a.r + b.r) / 2;
   const dr = a.r - b.r;
@@ -3080,7 +3519,7 @@ async function auditStyle(loaded, specs, styleId, lock) {
         continue;
       }
       try {
-        const png = decodePng(await readFile5(output.absolutePath));
+        const png = decodePng(await readFile6(output.absolutePath));
         const palette = extractPalette(png, 12);
         assets.push({
           assetId: spec.assetId,
@@ -3104,10 +3543,10 @@ async function auditStyle(loaded, specs, styleId, lock) {
   let referenceFromStyleImages = false;
   const refPalettes = [];
   for (const img of style.styleImages) {
-    const abs = path7.resolve(loaded.root, img.path);
+    const abs = path8.resolve(loaded.root, img.path);
     if (!existsSync5(abs)) continue;
     try {
-      refPalettes.push(extractPalette(decodePng(await readFile5(abs)), 12));
+      refPalettes.push(extractPalette(decodePng(await readFile6(abs)), 12));
     } catch {
     }
   }
@@ -3184,11 +3623,11 @@ function hex(c) {
 
 // src/pipeline/cache-health.ts
 import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile7, readdir, rm as rm4 } from "fs/promises";
-import path8 from "path";
+import { readFile as readFile8, readdir, rm as rm4 } from "fs/promises";
+import path9 from "path";
 
 // src/cache.ts
-import { mkdir as mkdir3, readFile as readFile6, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile7, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 import pathModule from "path";
 import { z as z3 } from "zod";
@@ -3204,10 +3643,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path17) {
-  if (!existsSync6(path17)) return { version: 1, hashes: {} };
+async function loadCache(path18) {
+  if (!existsSync6(path18)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile6(path17, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile7(path18, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -3219,18 +3658,18 @@ 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 mkdir3(pathModule.dirname(pathModule.resolve(path17)), { recursive: true });
-  const tmp = `${path17}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir3(pathModule.dirname(pathModule.resolve(path18)), { recursive: true });
+  const tmp = `${path18}.${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, path17);
+    await rename3(tmp, path18);
   } finally {
     await rm3(tmp, { force: true });
   }
@@ -3253,10 +3692,10 @@ function cachePathFor(lockPath) {
 // src/pipeline/cache-health.ts
 async function inspectCaches(lock, lockPath, options = {}) {
   if (options.prune && !existsSync7(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path8.resolve(lockPath)}`);
+    throw new Error(`Refusing to prune without an existing lockfile at ${path9.resolve(lockPath)}`);
   }
-  const contentDir = path8.resolve(path8.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path8.resolve(cachePathFor(lockPath));
+  const contentDir = path9.resolve(path9.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path9.resolve(cachePathFor(lockPath));
   const referenced = new Set(
     Object.values(lock.entries).flatMap((entry) => entry.outputs.map((output) => output.sha256))
   );
@@ -3270,7 +3709,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm4(path8.join(contentDir, name), { force: true });
+        await rm4(path9.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -3279,7 +3718,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 readFile7(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile8(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -3318,12 +3757,12 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path8.join(contentDir, entry.name);
+    const file = path9.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile7(file);
+      bytes = await readFile8(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -3370,7 +3809,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile7(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile8(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -3386,18 +3825,18 @@ async function inspectRemoteHashCache(remotePath) {
 
 // src/pipeline/pack.ts
 import { readFileSync as readFileSync2 } from "fs";
-import path9 from "path";
+import path10 from "path";
 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 = path9.dirname(path9.resolve(inputsFilePath));
+  const baseDir = path10.dirname(path10.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: path9.resolve(baseDir, e.path) };
+    return { id: e.id, path: path10.resolve(baseDir, e.path) };
   });
 }
 function packSprites(inputs, options = {}) {
@@ -3594,7 +4033,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     const cell = cells[id];
     const source = sources[id];
     if (source) {
-      placements.push({ id, path: path9.resolve(manifestDir, source), cell });
+      placements.push({ id, path: path10.resolve(manifestDir, source), cell });
       continue;
     }
     const entry = lock.entries[`${styleId}/${id}`];
@@ -3618,7 +4057,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 ? readFileSync2(path9.resolve(manifestDir, mount.base)) : void 0;
+  const basePng = mount.base ? readFileSync2(path10.resolve(manifestDir, mount.base)) : void 0;
   const mounted = mountSprites(placements, {
     cellWidth: mount.cellWidth,
     cellHeight: mount.cellHeight,
@@ -3628,7 +4067,7 @@ function mountStyle(lock, styleId, manifestDir, mount, cells, sources = {}, outp
     ...mounted,
     sources: mount.base ? [{
       id: "$base",
-      path: path9.resolve(manifestDir, mount.base),
+      path: path10.resolve(manifestDir, mount.base),
       sha256: sha256(basePng),
       included: true
     }, ...mounted.sources] : mounted.sources,
@@ -4040,7 +4479,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") {
@@ -4073,15 +4516,15 @@ async function poll(provider, lock, lockPath, opts = {}) {
 
 // src/pipeline/fetch.ts
 import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir4, readFile as readFile8, rename as rename4, rm as rm5, writeFile as writeFile4 } from "fs/promises";
-import path10 from "path";
+import { mkdir as mkdir4, readFile as readFile9, rename as rename4, rm as rm5, writeFile as writeFile4 } from "fs/promises";
+import path11 from "path";
 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 : path10.resolve(opts.cacheDir ?? path10.join(path10.dirname(lockPath), ".pixelkiln", "cache"));
+  const cacheDir = opts.cacheDir === false ? null : path11.resolve(opts.cacheDir ?? path11.join(path11.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;
@@ -4133,7 +4576,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             if (cacheDir) {
               await cacheMedia(
                 cacheDir,
-                await readFile8(target),
+                await readFile9(target),
                 recorded.mediaType ?? MediaType.PNG,
                 recorded.sha256
               );
@@ -4144,7 +4587,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  ${path10.relative(process.cwd(), target)}`);
+            log(`  cached  ${path11.relative(process.cwd(), target)}`);
           } else {
             if (!source.url) {
               throw new Error(`no source URL or cached bytes remain for ${source.role ?? "asset"}`);
@@ -4162,7 +4605,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
             );
           }
           if (cacheDir) await cacheMedia(cacheDir, buf, mediaType);
-          await mkdir4(path10.dirname(target), { recursive: true });
+          await mkdir4(path11.dirname(target), { recursive: true });
           const tmp = `${target}.pixelkiln.tmp`;
           await writeFile4(tmp, buf);
           outputs.push({
@@ -4174,7 +4617,7 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
           upsert(lock, key, { outputs: mergeOutputs(entry.outputs, outputs) });
           await saveLock(lockPath, lock);
           await rename4(tmp, target);
-          log(`  wrote   ${path10.relative(process.cwd(), target)}`);
+          log(`  wrote   ${path11.relative(process.cwd(), target)}`);
         }
         upsert(lock, key, {
           status: "downloaded",
@@ -4207,10 +4650,10 @@ async function fetchAssets(provider, specs, lock, lockPath, opts = {}) {
   return result;
 }
 async function readCachedMedia(cacheDir, hash, mediaType) {
-  const file = path10.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path11.join(cacheDir, cacheFileName(hash, mediaType));
   if (!existsSync8(file)) return null;
   try {
-    const buf = await readFile8(file);
+    const buf = await readFile9(file);
     if (sha256(buf) !== hash) return null;
     validateMedia(buf, mediaType);
     return buf;
@@ -4221,7 +4664,7 @@ async function readCachedMedia(cacheDir, hash, mediaType) {
 async function cacheMedia(cacheDir, buf, mediaType, knownHash) {
   const hash = knownHash ?? sha256(buf);
   validateMedia(buf, mediaType);
-  const file = path10.join(cacheDir, cacheFileName(hash, mediaType));
+  const file = path11.join(cacheDir, cacheFileName(hash, mediaType));
   if (await readCachedMedia(cacheDir, hash, mediaType)) return;
   await mkdir4(cacheDir, { recursive: true });
   const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
@@ -4264,7 +4707,7 @@ async function pushTags(provider, specs, lock, opts = {}) {
 // src/pipeline/doctor.ts
 import { constants, existsSync as existsSync9 } from "fs";
 import { access, stat as stat2 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 async function doctor(loaded, specs, lock, lockPath, opts = {}) {
   const checks = [];
   const add = (id, level, message2) => checks.push({ id, level, message: message2 });
@@ -4274,7 +4717,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) => path11.dirname(s.outFile)))];
+  const dirs = [...new Set(specs.map((s) => path12.dirname(s.outFile)))];
   const unwritable = [];
   for (const dir of dirs) {
     const ancestor = await nearestExistingDirectory(dir);
@@ -4296,7 +4739,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, path11.dirname(lockPath));
+      const absolute = spec ? currentEntryOutputPath(entry, spec, index) : resolveOutputPath(output.path, path12.dirname(lockPath));
       const owner = outputOwners.get(absolute);
       if (owner && owner !== key) duplicateOutputs.push(`${output.path} (${owner}, ${key})`);
       outputOwners.set(absolute, key);
@@ -4311,7 +4754,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 = path11.join(path11.dirname(lockPath), ".pixelkiln", "cache");
+  const cacheDir = path12.join(path12.dirname(lockPath), ".pixelkiln", "cache");
   const stranded = [];
   const invalidState = [];
   const staleMapUrls = [];
@@ -4327,7 +4770,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 = path11.join(
+      const cached = path12.join(
         cacheDir,
         cacheFileName(output.sha256, output.mediaType ?? MediaType.PNG)
       );
@@ -4362,8 +4805,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 {
@@ -4382,7 +4832,7 @@ async function nearestExistingDirectory(start) {
       if ((await stat2(current)).isDirectory()) return current;
     } catch {
     }
-    const parent = path11.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current) return current;
     current = parent;
   }
@@ -4390,8 +4840,8 @@ async function nearestExistingDirectory(start) {
 
 // src/pipeline/adopt.ts
 import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
-import path12 from "path";
+import { readFile as readFile10, writeFile as writeFile5 } from "fs/promises";
+import path13 from "path";
 async function adopt(provider, specs, lock, lockPath, opts = {}) {
   const log = opts.onProgress ?? (() => {
   });
@@ -4406,7 +4856,7 @@ async function adopt(provider, specs, lock, lockPath, opts = {}) {
       unmatchedLocal.push(`${spec.styleId}/${spec.assetId} (no file at ${spec.outFile})`);
       continue;
     }
-    const bytes = await readFile9(spec.outFile);
+    const bytes = await readFile10(spec.outFile);
     try {
       decodePng(bytes);
     } catch (err) {
@@ -4882,9 +5332,9 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/init.ts
-import { readdir as readdir2, readFile as readFile10, writeFile as writeFile6 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
-import path13 from "path";
+import path14 from "path";
 function pngSize(buf) {
   if (buf.length < 24) return null;
   const isPng = buf.readUInt32BE(0) === 2303741511 && buf.readUInt32BE(4) === 218765834;
@@ -4898,7 +5348,7 @@ function slugify(value) {
 async function walk(dir, exclude) {
   const out = [];
   for (const entry of await readdir2(dir, { withFileTypes: true })) {
-    const full = path13.join(dir, entry.name);
+    const full = path14.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);
@@ -4912,14 +5362,14 @@ async function scanAssets(root, opts = {}) {
   const skipped = [];
   const seen = /* @__PURE__ */ new Map();
   for (const file of files.sort()) {
-    const size = pngSize(await readFile10(file));
+    const size = pngSize(await readFile11(file));
     if (!size) {
       skipped.push(`${file} (not a readable PNG)`);
       continue;
     }
-    const rel = path13.relative(root, file);
-    const category = path13.dirname(rel) === "." ? "" : path13.dirname(rel);
-    let id = slugify(path13.basename(rel));
+    const rel = path14.relative(root, file);
+    const category = path14.dirname(rel) === "." ? "" : path14.dirname(rel);
+    let id = slugify(path14.basename(rel));
     if (seen.has(id)) {
       const n = seen.get(id) + 1;
       seen.set(id, n);
@@ -4975,16 +5425,16 @@ function mode(values) {
 }
 
 // src/pipeline/salvage.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import path14 from "path";
+import path15 from "path";
 async function loadClaims(lockPaths) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
     if (!existsSync12(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile11(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile12(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -5031,20 +5481,20 @@ function matchOrphanStyle(prompt, manifest) {
   return matchStyleByPattern(prompt, manifest);
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path14.resolve(ownManifestPath);
+  const own = path15.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path14.join(path14.dirname(path14.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path15.join(path15.dirname(path15.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path14.resolve(siblingManifestPath) === own) continue;
+    if (path15.resolve(siblingManifestPath) === own) continue;
     if (!existsSync12(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path14.basename(path14.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path15.basename(path15.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -5160,8 +5610,8 @@ async function applyTags(provider, decisions, existing, opts = {}) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir5, writeFile as writeFile7, readFile as readFile12 } from "fs/promises";
-import path15 from "path";
+import { mkdir as mkdir5, writeFile as writeFile7, readFile as readFile13 } from "fs/promises";
+import path16 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml2 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -5326,7 +5776,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path15.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path16.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]));
@@ -5355,9 +5805,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 = path15.join("_salvaged", `${assetId}.png`);
-            const outFile = path15.resolve(ctx.importDir, rel);
-            await mkdir5(path15.dirname(outFile), { recursive: true });
+            const rel = path16.join("_salvaged", `${assetId}.png`);
+            const outFile = path16.resolve(ctx.importDir, rel);
+            await mkdir5(path16.dirname(outFile), { recursive: true });
             await writeFile7(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
@@ -5384,7 +5834,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               error: null,
               sourceUrl: orphan.previewUrl,
               outputs: [{
-                path: portableOutputPath(outFile, path15.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path16.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -5408,7 +5858,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log });
-      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);
@@ -5418,9 +5868,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 }
 
 // src/workspace.ts
-import { mkdir as mkdir6, readFile as readFile13, rename as rename5, rm as rm6, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile14, rename as rename5, rm as rm6, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
-import path16 from "path";
+import path17 from "path";
 import { z as z4 } from "zod";
 var WorkspaceProjectSchema = z4.object({
   id: z4.string().min(1),
@@ -5448,7 +5898,7 @@ async function loadWorkspace(workspacePath) {
   if (!existsSync13(workspacePath)) return { version: 1, projects: [] };
   let raw;
   try {
-    raw = JSON.parse(await readFile13(workspacePath, "utf8"));
+    raw = JSON.parse(await readFile14(workspacePath, "utf8"));
   } catch (err) {
     throw new Error(
       `Workspace catalog at ${workspacePath} is malformed:
@@ -5462,7 +5912,7 @@ async function saveWorkspace(workspacePath, ws) {
     version: 1,
     projects: [...ws.projects].sort((a, b) => a.id.localeCompare(b.id))
   };
-  await mkdir6(path16.dirname(path16.resolve(workspacePath)), { recursive: true });
+  await mkdir6(path17.dirname(path17.resolve(workspacePath)), { recursive: true });
   const tmp = `${workspacePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile8(tmp, JSON.stringify(sorted, null, 2) + "\n");
@@ -5472,12 +5922,12 @@ async function saveWorkspace(workspacePath, ws) {
   }
 }
 function toPortablePath(dir, absolute) {
-  return path16.relative(dir, absolute).split(path16.sep).join("/");
+  return path17.relative(dir, absolute).split(path17.sep).join("/");
 }
 function resolveProject(dir, project) {
   return {
-    manifestPath: path16.resolve(dir, project.manifest.split("/").join(path16.sep)),
-    lockPath: path16.resolve(dir, project.lock.split("/").join(path16.sep))
+    manifestPath: path17.resolve(dir, project.manifest.split("/").join(path17.sep)),
+    lockPath: path17.resolve(dir, project.lock.split("/").join(path17.sep))
   };
 }
 function validateWorkspace(ws, dir) {
@@ -5490,7 +5940,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 (path16.isAbsolute(project.manifest) || path16.isAbsolute(project.lock)) {
+    if (path17.isAbsolute(project.manifest) || path17.isAbsolute(project.lock)) {
       diagnostics.push({
         id: "absolute-path",
         level: "warning",
@@ -5645,6 +6095,7 @@ async function workspaceStatus(ws, dir) {
 }
 export {
   AssetSchema,
+  ComfyUIProvider,
   DEFAULT_RATE_LIMIT,
   FAKE_PNG,
   FakeProvider,