pixelkiln 0.34.0 → 0.34.1

package/README.md

@@ -65,8 +65,8 @@ provenance and no long-lived npm token.
 
 ### Local human review
 
-`pixelkiln pick` opens a local candidate sheet — native aspect ratios, crisp
-small sprites, and no model choosing artwork for you.
+`pixelkiln pick` opens a local candidate sheet with native aspect ratios and
+crisp small sprites. No model chooses artwork for you.
 
 ![PixelKiln candidate review UI](./website/public/review-ui-showcase.jpg)
 
@@ -84,7 +84,7 @@ reviews from the page under that ceiling.
 Hand edits live beside the art, not in place of the record. [`pixelkiln edit`](docs/CLI.md#edit)
 opens a copy in your own editor; with `--edit` the gallery does the same, or opens
 it in a pinned, hash-verified [Pixelorama](docs/CLI.md#tools) build right in the page
-and saves it back — layers kept, frame and tile sets one file per member.
+and saves it back with its layers kept, one file per member for frame and tile sets.
 
 ![PixelKiln in-browser editor](./website/public/gallery-editor-showcase.jpg)
 

package/dist/cli.js

@@ -181,6 +181,54 @@ function specHash(spec, styleImageHashes, providerOptionIdentity = spec.provider
   );
 }
 
+// src/http.ts
+var MAX_RETRIES = 4;
+var DEFAULT_TIMEOUT_MS = 12e4;
+var sleepFor = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function shouldRetry(status) {
+  return status === 408 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+function backoffMs(attempt) {
+  const base = Math.min(1e3 * 2 ** attempt, 16e3);
+  return base + Math.floor(Math.random() * 400);
+}
+function retryAfterMs(value, now = Date.now()) {
+  if (!value) return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(value);
+  if (!Number.isFinite(date)) return null;
+  return Math.max(0, date - now);
+}
+function fetchWithRetry(request, opts = {}) {
+  const sleep3 = opts.sleep ?? sleepFor;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const send = request ?? ((input, init) => globalThis.fetch(input, init));
+  return async (input, init) => {
+    const { retries: perCall, ...rest } = init ?? {};
+    const retries = Math.max(0, perCall ?? opts.retries ?? MAX_RETRIES);
+    for (let attempt = 0; ; attempt++) {
+      const signal = rest.signal ?? AbortSignal.timeout(timeoutMs);
+      let res;
+      try {
+        res = await send(input, { ...rest, signal });
+      } catch (error) {
+        if (rest.signal?.aborted || attempt >= retries) throw error;
+        const waitMs2 = backoffMs(attempt);
+        opts.onRetry?.({ attempt, waitMs: waitMs2, error });
+        await sleep3(waitMs2);
+        continue;
+      }
+      if (res.ok || !shouldRetry(res.status) || attempt >= retries) return res;
+      const waitMs = retryAfterMs(res.headers.get("retry-after")) ?? backoffMs(attempt);
+      await res.body?.cancel().catch(() => {
+      });
+      opts.onRetry?.({ attempt, waitMs, status: res.status });
+      await sleep3(waitMs);
+    }
+  };
+}
+
 // src/png.ts
 import { deflateSync, inflateSync } from "zlib";
 var SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
@@ -636,14 +684,15 @@ var BUILTIN_BINDINGS = /* @__PURE__ */ new Set([
   "strength"
 ]);
 var ComfyUIClient = class {
-  constructor(baseUrl = process.env.COMFYUI_BASE_URL ?? DEFAULT_BASE_URL, request = fetch) {
-    this.request = request;
+  baseUrl;
+  request;
+  constructor(baseUrl = process.env.COMFYUI_BASE_URL ?? DEFAULT_BASE_URL, request, retry) {
     this.baseUrl = normalizeBaseUrl(baseUrl);
+    this.request = fetchWithRetry(request, retry);
   }
-  request;
-  baseUrl;
+  /** A connectivity check should answer fast, so it does not retry. */
   async checkConnection() {
-    const value = await this.json("system_stats");
+    const value = await this.json("system_stats", { retries: 0 });
     if (!isObject(value)) throw new Error("ComfyUI returned invalid system stats");
   }
   async submit(workflow) {
@@ -1505,24 +1554,7 @@ import path3 from "path";
 // src/client.ts
 import { z } from "zod";
 var BASE = process.env.PIXELLAB_API_BASE ?? "https://api.pixellab.ai/v2";
-var MAX_RETRIES = 4;
 var MAX_DOWNLOAD_BYTES = 64 * 1024 * 1024;
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-function shouldRetry(status) {
-  return status === 429 || status === 408 || status >= 500;
-}
-function backoffMs(attempt) {
-  const base = Math.min(1e3 * 2 ** attempt, 16e3);
-  return base + Math.floor(Math.random() * 400);
-}
-function retryAfterMs(value, now = Date.now()) {
-  if (!value) return null;
-  const seconds = Number(value);
-  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
-  const date = Date.parse(value);
-  if (!Number.isFinite(date)) return null;
-  return Math.max(0, date - now);
-}
 var BalanceResponseSchema = z.object({
   credits: z.object({ usd: z.number() }).passthrough(),
   subscription: z.object({
@@ -1598,45 +1630,22 @@ var PixelLabError = class extends Error {
 var PixelLabClient = class {
   constructor(apiKey, timeoutMs = 12e4) {
     this.apiKey = apiKey;
-    this.timeoutMs = timeoutMs;
     if (!apiKey) throw new Error("PIXELLAB_API_KEY is required");
+    this.http = fetchWithRetry(void 0, { timeoutMs });
   }
   apiKey;
-  timeoutMs;
-  /**
-   * Retries only what is safe to retry: transport failures, 429, and 5xx.
-   * A 4xx other than 429 is a bad request and retrying it just wastes time.
-   *
-   * POSTs that create objects are included, which is a deliberate trade: the
-   * failure mode of not retrying (a dropped asset in a 65-item run) is more
-   * common than the failure mode of retrying (a duplicate object), and a
-   * duplicate is visible and free to delete whereas a silent gap is neither.
-   */
-  async request(path32, init, attempt = 0) {
+  http;
+  /** Retries transport failures, 429, and 5xx; see http.ts for the policy. */
+  async request(path32, init) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
-    let res;
-    try {
-      res = await fetch(`${BASE}${path32}`, {
-        ...init,
-        signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
-        headers: {
-          Authorization: auth,
-          "Content-Type": "application/json",
-          ...init?.headers ?? {}
-        }
-      });
-    } catch (err) {
-      if (attempt < MAX_RETRIES) {
-        await sleep(backoffMs(attempt));
-        return this.request(path32, init, attempt + 1);
+    const res = await this.http(`${BASE}${path32}`, {
+      ...init,
+      headers: {
+        Authorization: auth,
+        "Content-Type": "application/json",
+        ...init?.headers ?? {}
       }
-      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(path32, init, attempt + 1);
-    }
+    });
     const text = await res.text();
     if (!res.ok) {
       throw new PixelLabError(`${init?.method ?? "GET"} ${path32} \u2192 ${res.status}`, res.status, text);
@@ -1824,7 +1833,7 @@ var PixelLabClient = class {
   }
   /** Storage URLs are public; no auth header, and sending one can break the CDN request. */
   async download(url) {
-    const res = await fetch(url, { signal: AbortSignal.timeout(this.timeoutMs) });
+    const res = await this.http(url);
     if (!res.ok) throw new PixelLabError(`download ${url} \u2192 ${res.status}`, res.status, "");
     const declared = Number(res.headers.get("content-length"));
     if (Number.isFinite(declared) && declared > MAX_DOWNLOAD_BYTES) {
@@ -2631,10 +2640,10 @@ function firstUrl(urls) {
 var DEFAULT_BASE_URL2 = "https://api.retrodiffusion.ai/v1";
 var SOURCE_PROTOCOL = "retrodiffusion:";
 var RetroDiffusionClient = class {
-  constructor(token, baseUrl = DEFAULT_BASE_URL2, request = fetch) {
+  constructor(token, baseUrl = DEFAULT_BASE_URL2, request, retry) {
     this.token = token;
     this.baseUrl = baseUrl;
-    this.request = request;
+    this.request = fetchWithRetry(request, retry);
   }
   token;
   baseUrl;
@@ -2669,6 +2678,12 @@ var RetroDiffusionClient = class {
     }
     return balance;
   }
+  /** Result URLs are signed; no token header, and the same retry policy as the API. */
+  async download(url) {
+    const response = await this.request(url);
+    if (!response.ok) throw new Error(`Retro Diffusion download failed (${response.status})`);
+    return Buffer.from(await response.arrayBuffer());
+  }
   async call(path32, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
     const response = await this.request(`${this.baseUrl}${path32}`, {
@@ -2864,9 +2879,7 @@ var RetroDiffusionProvider = class _RetroDiffusionProvider {
   async downloadResolved(url) {
     const data = /^data:[^;]+;base64,(.+)$/.exec(url)?.[1];
     if (data) return Buffer.from(data, "base64");
-    const response = await fetch(url);
-    if (!response.ok) throw new Error(`Retro Diffusion download failed (${response.status})`);
-    return Buffer.from(await response.arrayBuffer());
+    return this.client.download(url);
   }
   async balance() {
     return { unit: "usd", remaining: await this.client.balance() };
@@ -2993,11 +3006,11 @@ var PROTECTED_PARAMETERS = /* @__PURE__ */ new Set([
   "width"
 ]);
 var ScenarioClient = class {
-  constructor(apiKey, apiSecret, baseUrl = DEFAULT_BASE_URL3, request = fetch) {
+  constructor(apiKey, apiSecret, baseUrl = DEFAULT_BASE_URL3, request, retry) {
     this.apiKey = apiKey;
     this.apiSecret = apiSecret;
     this.baseUrl = baseUrl;
-    this.request = request;
+    this.request = fetchWithRetry(request, retry);
   }
   apiKey;
   apiSecret;
@@ -3095,8 +3108,9 @@ var ScenarioClient = class {
     }
     return bytes;
   }
+  /** A connectivity check should answer fast, so it does not retry. */
   async checkConnection() {
-    await this.call("/models", {}, { pageSize: "1" });
+    await this.call("/models", { retries: 0 }, { pageSize: "1" });
   }
   async call(pathname, init = {}, query = {}) {
     if (!this.apiKey || !this.apiSecret) {
@@ -6628,7 +6642,7 @@ async function revertGeneration(provider, spec, lock, lockPath, opts) {
 
 // src/pipeline/submit.ts
 var IN_FLIGHT_POLL_MS = 5e3;
-var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
   const limits = provider.rateLimit?.() ?? DEFAULT_RATE_LIMIT;
   const maxInFlight = opts.maxInFlight ?? limits.maxInFlight;
@@ -6683,7 +6697,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
           `Timed out waiting for a generation slot` + (lastSlotError ? `; last poll error: ${lastSlotError}` : "")
         );
       }
-      await sleep2(slotPollMs);
+      await sleep(slotPollMs);
       await pruneInFlight();
     }
   }
@@ -6691,7 +6705,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
     const estimate = estimates.get(key);
     await waitForSlot();
     const since = Date.now() - lastSubmitAt;
-    if (since < spacing) await sleep2(spacing - since);
+    if (since < spacing) await sleep(spacing - since);
     await requireRevisionReady(spec, lock);
     const previousEntry = lock.entries[key];
     const resumesCheckpoint = Boolean(
@@ -6809,7 +6823,7 @@ async function submit(provider, loaded, items, lock, lockPath, opts = {}) {
 }
 
 // src/pipeline/poll.ts
-var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 async function poll(provider, lock, lockPath, opts = {}) {
   const interval = opts.intervalMs ?? 5e3;
   const timeout = opts.timeoutMs ?? 15 * 60 * 1e3;
@@ -6886,7 +6900,7 @@ async function poll(provider, lock, lockPath, opts = {}) {
       }
     }
     await saveLock(lockPath, lock);
-    if (pending().length > 0) await sleep3(interval);
+    if (pending().length > 0) await sleep2(interval);
   }
   await saveLock(lockPath, lock);
   return result;
@@ -7800,8 +7814,25 @@ document.getElementById('submit').onclick = async () => {
 
 // src/pick/review-server.ts
 import { createServer } from "http";
-import { spawn } from "child_process";
 import { readFile as readFile11 } from "fs/promises";
+
+// src/open.ts
+import { spawn } from "child_process";
+function openExternal(target, command = defaultOpenCommand()) {
+  const [program, ...args] = command;
+  const child = spawn(program, [...args, target], { stdio: "ignore", detached: true });
+  child.on("error", () => {
+  });
+  child.unref();
+  return command.join(" ");
+}
+function defaultOpenCommand(platform = process.platform) {
+  if (platform === "darwin") return ["open"];
+  if (platform === "win32") return ["cmd", "/c", "start", ""];
+  return ["xdg-open"];
+}
+
+// src/pick/review-server.ts
 function serveReviewPage(opts) {
   const log2 = opts.onProgress ?? (() => {
   });
@@ -7873,10 +7904,9 @@ function serveReviewPage(opts) {
     server.listen(opts.port ?? 0, "127.0.0.1", () => {
       const address = server.address();
       const port = typeof address === "object" && address ? address.port : opts.port;
-      opts.onReady(`http://127.0.0.1:${port}/`);
-      if (opts.open !== false && process.platform === "darwin") {
-        spawn("open", [`http://127.0.0.1:${port}/`], { stdio: "ignore", detached: true }).unref();
-      }
+      const url = `http://127.0.0.1:${port}/`;
+      opts.onReady(url);
+      if (opts.open !== false) openExternal(url);
     });
   });
 }
@@ -8449,7 +8479,6 @@ async function applyManifestEdit(manifestPath, edit) {
 }
 
 // src/pipeline/hand-edit.ts
-import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync18 } from "fs";
 import { copyFile, mkdir as mkdir6, readFile as readFile15, rename as rename7, rm as rm8, writeFile as writeFile9 } from "fs/promises";
 import path21 from "path";
@@ -8689,13 +8718,8 @@ async function replaceFile(file, bytes) {
   }
 }
 function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
-  const command = editor?.trim() ? editor.trim().split(/\s+/) : process.platform === "darwin" ? ["open"] : process.platform === "win32" ? ["cmd", "/c", "start", ""] : ["xdg-open"];
-  const [program, ...args] = command;
-  const child = spawn2(program, [...args, file], { stdio: "ignore", detached: true });
-  child.on("error", () => {
-  });
-  child.unref();
-  return command.join(" ");
+  const command = editor?.trim() ? editor.trim().split(/\s+/) : defaultOpenCommand();
+  return openExternal(file, command);
 }
 
 // src/gallery/edit.ts
@@ -9346,7 +9370,6 @@ async function buildWorkspaceGallerySnapshot(opts) {
 }
 
 // src/gallery/server.ts
-import { spawn as spawn3 } from "child_process";
 import { randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
 import { readFile as readFile17 } from "fs/promises";
@@ -12126,9 +12149,7 @@ async function serveGallery(opts) {
     });
   });
   opts.onReady?.(url);
-  if (opts.open !== false && process.platform === "darwin") {
-    spawn3("open", [url], { stdio: "ignore", detached: true }).unref();
-  }
+  if (opts.open !== false) openExternal(url);
   return {
     url,
     session,