pixelkiln 0.26.0 → 0.27.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path28 from "path";
-import { existsSync as existsSync22 } from "fs";
-import { readFile as readFile22 } from "fs/promises";
+import path30 from "path";
+import { existsSync as existsSync23 } from "fs";
+import { readFile as readFile25 } from "fs/promises";
 
 // src/env.ts
 import { readFileSync, existsSync } from "fs";
@@ -134,10 +134,10 @@ import { createReadStream } from "fs";
 function sha256(data) {
   return createHash("sha256").update(data).digest("hex");
 }
-async function sha256File(path29) {
+async function sha256File(path31) {
   return new Promise((resolve, reject) => {
     const hash = createHash("sha256");
-    const stream = createReadStream(path29);
+    const stream = createReadStream(path31);
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -1617,11 +1617,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(path29, init, attempt = 0) {
+  async request(path31, init, attempt = 0) {
     const auth = this.apiKey.startsWith("Bearer ") ? this.apiKey : `Bearer ${this.apiKey}`;
     let res;
     try {
-      res = await fetch(`${BASE}${path29}`, {
+      res = await fetch(`${BASE}${path31}`, {
         ...init,
         signal: init?.signal ?? AbortSignal.timeout(this.timeoutMs),
         headers: {
@@ -1633,24 +1633,24 @@ var PixelLabClient = class {
     } catch (err) {
       if (attempt < MAX_RETRIES) {
         await sleep(backoffMs(attempt));
-        return this.request(path29, init, attempt + 1);
+        return this.request(path31, 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(path29, init, attempt + 1);
+      return this.request(path31, init, attempt + 1);
     }
     const text = await res.text();
     if (!res.ok) {
-      throw new PixelLabError(`${init?.method ?? "GET"} ${path29} \u2192 ${res.status}`, res.status, text);
+      throw new PixelLabError(`${init?.method ?? "GET"} ${path31} \u2192 ${res.status}`, res.status, text);
     }
     if (!text) return {};
     try {
       return JSON.parse(text);
     } catch {
-      throw new Error(`${init?.method ?? "GET"} ${path29} returned invalid JSON`);
+      throw new Error(`${init?.method ?? "GET"} ${path31} returned invalid JSON`);
     }
   }
   async balance() {
@@ -2626,9 +2626,9 @@ var RetroDiffusionClient = class {
     }
     return balance;
   }
-  async call(path29, init = {}) {
+  async call(path31, init = {}) {
     if (!this.token) throw new Error("RD_API_KEY is not set");
-    const response = await this.request(`${this.baseUrl}${path29}`, {
+    const response = await this.request(`${this.baseUrl}${path31}`, {
       ...init,
       headers: {
         "Content-Type": "application/json",
@@ -6872,10 +6872,10 @@ function isSha256Hash(value) {
 function parseCache(value) {
   return HashCacheSchema.parse(value);
 }
-async function loadCache(path29) {
-  if (!existsSync11(path29)) return { version: 1, hashes: {} };
+async function loadCache(path31) {
+  if (!existsSync11(path31)) return { version: 1, hashes: {} };
   try {
-    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path29, "utf8")));
+    const parsed = HashCacheSchema.safeParse(JSON.parse(await readFile8(path31, "utf8")));
     if (!parsed.success) return { version: 1, hashes: {} };
     return {
       version: 1,
@@ -6887,18 +6887,18 @@ async function loadCache(path29) {
     return { version: 1, hashes: {} };
   }
 }
-async function saveCache(path29, cache) {
+async function saveCache(path31, 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 mkdir4(pathModule.dirname(pathModule.resolve(path29)), { recursive: true });
-  const tmp = `${path29}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await mkdir4(pathModule.dirname(pathModule.resolve(path31)), { recursive: true });
+  const tmp = `${path31}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile4(tmp, JSON.stringify({ version: 1, hashes: sorted }, null, 2) + "\n");
-    await rename4(tmp, path29);
+    await rename4(tmp, path31);
   } finally {
     await rm5(tmp, { force: true });
   }
@@ -7842,7 +7842,7 @@ async function runPicker(provider, lock, lockPath, opts = {}) {
 // src/gallery/snapshot.ts
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync17 } from "fs";
-import { readFile as readFile15, stat as stat3 } from "fs/promises";
+import { readFile as readFile16, stat as stat3 } from "fs/promises";
 import path22 from "path";
 
 // src/workspace.ts
@@ -7980,7 +7980,7 @@ function validateWorkspace(ws, dir) {
 
 // src/gallery/edit.ts
 import path21 from "path";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/manifest-edit.ts
 import { readFile as readFile14, rename as rename6, rm as rm7, writeFile as writeFile8 } from "fs/promises";
@@ -8234,8 +8234,9 @@ async function applyManifestEdit(manifestPath, edit) {
 // src/pipeline/hand-edit.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync16 } from "fs";
-import { copyFile, mkdir as mkdir6 } from "fs/promises";
+import { copyFile, mkdir as mkdir6, readFile as readFile15, rename as rename7, rm as rm8, writeFile as writeFile9 } from "fs/promises";
 import path20 from "path";
+import { z as z6 } from "zod";
 var HAND_EDIT_DIR = "edits";
 function handEditPath(loaded, spec) {
   const style = loaded.manifest.styles[spec.styleId];
@@ -8305,6 +8306,89 @@ async function detachHandEdit(loaded, spec, opts = {}) {
   });
   return { manifestSha256: result.sha256, changed: result.changed };
 }
+var HandEditCompanionSchema = z6.object({
+  version: z6.literal(1),
+  /** sha256 of the generated art the edit started from; null when it started from untracked art. */
+  basedOn: z6.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  /** sha256 of the edit PNG as saved, so a later change by another tool is visible. */
+  sha256: z6.string().regex(/^[0-9a-f]{64}$/),
+  /** Editor identity the bridge reported, e.g. `pixelorama@v1.2.2-stable`. */
+  editor: z6.string().min(1),
+  protocol: z6.number().int().positive(),
+  savedAt: z6.string().datetime(),
+  /** Basename of the layered project file beside the edit, when one was kept. */
+  project: z6.string().min(1).nullable()
+}).strict();
+function handEditCompanionPath(editPath) {
+  return editPath.replace(/\.png$/i, "") + ".edit.json";
+}
+function handEditProjectPath(editPath) {
+  return editPath.replace(/\.png$/i, "") + ".pxo";
+}
+async function readHandEditCompanion(editPath) {
+  let text;
+  try {
+    text = await readFile15(handEditCompanionPath(editPath), "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    return HandEditCompanionSchema.parse(JSON.parse(text));
+  } catch {
+    return null;
+  }
+}
+var MAX_HAND_EDIT_BYTES = 16 * 1024 * 1024;
+async function saveHandEdit(loaded, lock, spec, input) {
+  if (input.png.length > MAX_HAND_EDIT_BYTES) {
+    throw new ManifestEditError(`the edit is ${input.png.length} bytes; the limit is ${MAX_HAND_EDIT_BYTES}`);
+  }
+  if (input.project && input.project.length > MAX_HAND_EDIT_BYTES) {
+    throw new ManifestEditError(`the project file is ${input.project.length} bytes; the limit is ${MAX_HAND_EDIT_BYTES}`);
+  }
+  let decoded;
+  try {
+    validateMedia(input.png, MediaType.PNG);
+    decoded = decodePng(input.png);
+  } catch (error) {
+    throw new ManifestEditError(`the edit is not a valid PNG: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const base = handEditBase(spec, lock);
+  const expected = base ? decodePng(await readFile15(base)) : { width: spec.width, height: spec.height };
+  if (decoded.width !== expected.width || decoded.height !== expected.height) {
+    throw new ManifestEditError(
+      `the edit is ${decoded.width}\xD7${decoded.height}; ${spec.styleId}/${spec.assetId} is ${expected.width}\xD7${expected.height}`
+    );
+  }
+  const started = await startHandEdit(loaded, lock, spec, { expectedSha256: input.expectedSha256 });
+  const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
+  const basedOn = entry ? primaryOutput(entry)?.sha256 ?? null : null;
+  const digest2 = sha256(input.png);
+  const projectPath = input.project ? handEditProjectPath(started.editPath) : null;
+  const companion = {
+    version: 1,
+    basedOn,
+    sha256: digest2,
+    editor: input.editor,
+    protocol: input.protocol,
+    savedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    project: projectPath ? path20.basename(projectPath) : null
+  };
+  await replaceFile(started.editPath, input.png);
+  if (projectPath && input.project) await replaceFile(projectPath, input.project);
+  const companionPath = handEditCompanionPath(started.editPath);
+  await replaceFile(companionPath, JSON.stringify(companion, null, 2) + "\n");
+  return { ...started, sha256: digest2, basedOn, companionPath, projectPath };
+}
+async function replaceFile(file, bytes) {
+  const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await writeFile9(tmp, bytes);
+    await rename7(tmp, file);
+  } finally {
+    await rm8(tmp, { force: true });
+  }
+}
 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;
@@ -8316,22 +8400,37 @@ function openInEditor(file, editor = process.env.PIXELKILN_EDITOR) {
 }
 
 // src/gallery/edit.ts
-var HandEditRequestSchema = z6.discriminatedUnion("action", [
-  z6.object({
-    action: z6.literal("start-edit"),
-    project: z6.string().min(1).optional(),
-    assetId: z6.string().min(1),
-    styleId: z6.string().min(1),
-    expectedSha256: z6.string().regex(/^[0-9a-f]{64}$/),
+var Base64 = z7.string().regex(/^[A-Za-z0-9+/]*={0,2}$/).max(Math.ceil(MAX_HAND_EDIT_BYTES / 3) * 4);
+var HandEditRequestSchema = z7.discriminatedUnion("action", [
+  z7.object({
+    action: z7.literal("start-edit"),
+    project: z7.string().min(1).optional(),
+    assetId: z7.string().min(1),
+    styleId: z7.string().min(1),
+    expectedSha256: z7.string().regex(/^[0-9a-f]{64}$/),
     /** Also launch the author's editor on the file. */
-    open: z6.boolean().optional()
+    open: z7.boolean().optional()
   }).strict(),
-  z6.object({
-    action: z6.literal("detach-edit"),
-    project: z6.string().min(1).optional(),
-    assetId: z6.string().min(1),
-    styleId: z6.string().min(1),
-    expectedSha256: z6.string().regex(/^[0-9a-f]{64}$/)
+  z7.object({
+    action: z7.literal("detach-edit"),
+    project: z7.string().min(1).optional(),
+    assetId: z7.string().min(1),
+    styleId: z7.string().min(1),
+    expectedSha256: z7.string().regex(/^[0-9a-f]{64}$/)
+  }).strict(),
+  /** From the in-browser editor: the page holds the bytes, the server validates and writes. */
+  z7.object({
+    action: z7.literal("save-edit"),
+    project: z7.string().min(1).optional(),
+    assetId: z7.string().min(1),
+    styleId: z7.string().min(1),
+    expectedSha256: z7.string().regex(/^[0-9a-f]{64}$/),
+    png: Base64.min(1),
+    /** The editor's layered project file, kept beside the edit. */
+    pxo: Base64.optional(),
+    /** Editor identity from the bridge's ready message. */
+    editor: z7.string().min(1).max(200),
+    protocol: z7.number().int().positive()
   }).strict()
 ]);
 function createGalleryEditHandler(opts) {
@@ -8352,6 +8451,15 @@ function createGalleryEditHandler(opts) {
           const command = (opts.openEditor ?? openInEditor)(started.editPath);
           log2(`  opened with: ${command}`);
         }
+      } else if (request.action === "save-edit") {
+        const saved = await saveHandEdit(ctx.loaded, ctx.lock, spec, {
+          png: Buffer.from(request.png, "base64"),
+          ...request.pxo ? { project: Buffer.from(request.pxo, "base64") } : {},
+          editor: request.editor,
+          protocol: request.protocol,
+          expectedSha256: request.expectedSha256
+        });
+        log2(`  hand edit saved from ${request.editor}: ${saved.source}${saved.declared ? " (declared in the manifest)" : ""}${saved.projectPath ? " + project file" : ""}`);
       } else {
         const result2 = await detachHandEdit(ctx.loaded, spec, { expectedSha256: request.expectedSha256 });
         if (result2.changed) log2(`  hand edit detached: ${request.styleId}/${request.assetId} (file kept)`);
@@ -8501,7 +8609,7 @@ async function buildGallerySnapshot(opts) {
   const media = /* @__PURE__ */ new Map();
   const plan = await buildPlan(specs, lock);
   const items = [];
-  const manifestText = await readFile15(loaded.path, "utf8");
+  const manifestText = await readFile16(loaded.path, "utf8");
   const manifestSha256 = sha256(manifestText);
   let rawStyles = {};
   try {
@@ -8516,6 +8624,7 @@ async function buildGallerySnapshot(opts) {
     let outputs;
     let edit = null;
     let editStatus = null;
+    let editMeta = null;
     if (entry && entry.outputs.length) {
       outputs = await Promise.all(
         entry.outputs.map(
@@ -8527,7 +8636,19 @@ async function buildGallerySnapshot(opts) {
         const editSha = existsSync17(editPath) ? await sha256File(editPath) : null;
         edit = await describeOutput(media, root, editPath, { sha256: editSha });
         const generated = outputs[0];
-        editStatus = !edit.exists ? "missing" : generated && editSha === generated.sha256 ? "same" : generated?.modifiedAt && edit.modifiedAt && generated.modifiedAt > edit.modifiedAt && generated.exists ? "regenerated-since" : "edited";
+        const companion = await readHandEditCompanion(editPath);
+        if (companion) {
+          const projectPath = handEditProjectPath(editPath);
+          editMeta = {
+            editor: companion.editor,
+            savedAt: companion.savedAt,
+            basedOn: companion.basedOn,
+            changedSince: editSha !== null && editSha !== companion.sha256,
+            project: companion.project && existsSync17(projectPath) ? portableOutputPath(projectPath, root) : null
+          };
+        }
+        const regenerated = companion ? generated?.sha256 !== void 0 && generated.sha256 !== null && companion.basedOn !== generated.sha256 : Boolean(generated?.modifiedAt && edit.modifiedAt && generated.modifiedAt > edit.modifiedAt && generated.exists);
+        editStatus = !edit.exists ? "missing" : generated && editSha === generated.sha256 ? "same" : regenerated ? "regenerated-since" : "edited";
       }
     } else if (spec.source) {
       outputs = [await describeOutput(media, root, path22.resolve(root, spec.source))];
@@ -8577,6 +8698,7 @@ async function buildGallerySnapshot(opts) {
       source: spec.source ?? null,
       edit,
       editStatus,
+      editMeta,
       upstreamUrl: entry?.provider === "pixellab" ? pixelLabObjectUrl(entry.generator, entry.objectId) : null,
       refreshable: Boolean(entry && entry.status === "downloaded" && entry.outputs.length && (entry.sourceUrls?.length || entry.sourceUrl)),
       tags: spec.tags,
@@ -8633,6 +8755,7 @@ async function buildGallerySnapshot(opts) {
       source: null,
       edit: null,
       editStatus: null,
+      editMeta: null,
       upstreamUrl: entry.provider === "pixellab" ? pixelLabObjectUrl(entry.generator, entry.objectId) : null,
       refreshable: false,
       tags: [],
@@ -8774,7 +8897,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
         root: loaded.root,
         provider: loaded.manifest.provider,
         account: project.account ?? null,
-        manifestSha256: manifestSha256 ?? sha256(await readFile15(manifestPath, "utf8")),
+        manifestSha256: manifestSha256 ?? sha256(await readFile16(manifestPath, "utf8")),
         entries: Object.keys(lock.entries).length,
         items: projectItems.length,
         spendByUnit: spendByUnit(lock),
@@ -8832,7 +8955,7 @@ async function buildWorkspaceGallerySnapshot(opts) {
 import { spawn as spawn3 } from "child_process";
 import { randomBytes } from "crypto";
 import { createServer as createServer2 } from "http";
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 
 // src/gallery/page.ts
 function renderGallery(snapshot, opts = {}) {
@@ -8840,6 +8963,7 @@ function renderGallery(snapshot, opts = {}) {
   const session = JSON.stringify(opts.session ?? null);
   const editable = JSON.stringify(Boolean(opts.editable && opts.session));
   const generation = JSON.stringify(Boolean(opts.generation && opts.session));
+  const editor = JSON.stringify(Boolean(opts.editor && opts.session));
   const title = `pixelkiln \u2014 ${snapshot.project?.name ?? "workspace"}`;
   return `<!doctype html>
 <html lang="en">
@@ -9045,6 +9169,15 @@ function renderGallery(snapshot, opts = {}) {
   .job .acts button { padding:3px 9px; font-size:12px; }
   .job pre { grid-column:1 / -1; margin:0; padding:8px 10px; border-top:1px solid var(--line);
     font:11.5px/1.45 var(--mono); color:var(--dim); max-height:220px; overflow:auto; white-space:pre-wrap; }
+  #tools { width:min(100%,var(--content)); margin:0 auto; padding:0 22px 12px; }
+  #tools:empty { display:none; }
+  .tool { border:1px solid var(--line); background:var(--panel-deep); padding:8px 12px; display:grid;
+    grid-template-columns:auto 1fr auto; gap:6px 14px; align-items:center; font-size:12.5px; }
+  .tool .ph { display:inline-flex; align-items:center; gap:6px; font:650 12px/1 var(--mono); white-space:nowrap; }
+  .tool .last { color:var(--dim); min-width:0; }
+  .tool .acts { display:flex; gap:6px; }
+  .tool .acts button { padding:3px 9px; font-size:12px; }
+  .tool progress { grid-column:1 / -1; width:100%; height:6px; accent-color:var(--accent); }
   .budget { color:var(--dim); }
   .budget b { color:var(--text); }
   .dialog { position:fixed; inset:0; z-index:30; display:grid; place-items:center; background:rgba(0,0,0,.55); }
@@ -9065,6 +9198,16 @@ function renderGallery(snapshot, opts = {}) {
     border-left:1px solid var(--line-strong); display:grid; grid-template-rows:auto 1fr; min-width:0; }
   .sheet.review-host { width:min(1180px, 94vw); }
   .sheet.compare-host { width:min(1500px, 96vw); }
+  .sheet.editor-host { width:min(1400px, 96vw); grid-template-rows:auto 1fr; }
+  .sheet.editor-host .rbar b { font:650 12.5px/1.4 var(--mono); color:var(--text); }
+  .sheet.editor-host .rbar .acts { margin-left:auto; display:flex; gap:8px; align-items:center; }
+  .sheet.editor-host .rbar .st { display:inline-flex; align-items:center; gap:6px; font:650 11.5px/1 var(--mono); }
+  .sheet.editor-host .rbar .msg { color:var(--bad); font-size:12.5px; }
+  .sheet.editor-host .stage { position:relative; min-height:0; }
+  .sheet.editor-host .stage iframe { position:absolute; inset:0; }
+  .sheet.editor-host .loading { position:absolute; inset:0; display:grid; place-items:center; background:var(--bg);
+    color:var(--dim); text-align:center; padding:24px; }
+  .sheet.editor-host .loading b { display:block; color:var(--text); margin-bottom:6px; }
   .sheet .rbar { display:flex; align-items:center; gap:12px; padding:10px 16px; border-bottom:1px solid var(--line-strong);
     background:var(--panel); font-size:13px; flex-wrap:wrap; }
   .sheet .rbar span { color:var(--dim); }
@@ -9103,7 +9246,7 @@ function renderGallery(snapshot, opts = {}) {
   .tray .pick img { width:22px; height:22px; object-fit:contain; image-rendering:pixelated; }
   .tray .pick button { padding:0 5px; border-color:transparent; color:var(--dim); font-size:12px; }
   .tray > button { padding:5px 11px; font-size:12.5px; }
-  @media (max-width: 900px) { .sheet.review-host, .sheet.compare-host { width:100vw; } }
+  @media (max-width: 900px) { .sheet.review-host, .sheet.compare-host, .sheet.editor-host { width:100vw; } }
   .drawer .gen { display:flex; gap:8px; flex-wrap:wrap; margin-top:12px; }
   .pair { display:grid; grid-template-columns:1fr 1fr; gap:8px; margin:8px 0 10px; }
   .pair figure { margin:0; border:1px solid var(--line); background:var(--panel-deep); background-image:var(--checker);
@@ -9151,6 +9294,7 @@ function renderGallery(snapshot, opts = {}) {
   <div class="totals" id="totals"></div>
   <div class="chips" id="chips"></div>
   <div id="jobs"></div>
+  <div id="tools"></div>
 </header>
 <main id="root"></main>
 <footer>
@@ -9169,6 +9313,7 @@ const INITIAL = ${data};
 const SESSION = ${session};
 const EDITABLE = ${editable};
 const GENERATION = ${generation};
+const EDITOR = ${editor};
 let snap = INITIAL;
 const STATE_TONE = {
   ok: 'ok', stale: 'warn', orphaned: 'warn', untracked: 'warn', blocked: 'warn',
@@ -9336,6 +9481,92 @@ function renderJobs() {
     host.append(row);
   }
 }
+// ---- the in-browser editor (only when the server serves one) -------------
+// The build is a 46 MB web export fetched once into a user-level cache and
+// verified against hashes this PixelKiln release carries; the page only
+// reports and asks, the server downloads. Nothing is fetched without a click.
+
+let ED = null;
+let edTimer = null;
+const fmtMb = (bytes) => (bytes / 1e6).toFixed(1) + ' MB';
+async function pollEditor() {
+  if (!EDITOR) return;
+  try {
+    const res = await fetch('/api/editor', { cache: 'no-store' });
+    if (!res.ok) throw new Error(await res.text());
+    ED = await res.json();
+  } catch (err) {
+    ED = { error: 'status unavailable: ' + err.message, installed: false, installing: null, missing: [], totalBytes: 0 };
+  }
+  renderTools();
+  clearTimeout(edTimer);
+  if (ED.installing) edTimer = setTimeout(pollEditor, 1000);
+  else if (ui.open) renderDrawer();
+}
+async function installEditor() {
+  try {
+    const res = await fetch('/api/editor/install', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'X-Pixelkiln-Session': SESSION },
+      body: '{}',
+    });
+    if (!res.ok) throw new Error(await res.text());
+    ED = await res.json();
+  } catch (err) {
+    ED = Object.assign({}, ED, { error: err.message });
+  }
+  renderTools();
+  clearTimeout(edTimer);
+  edTimer = setTimeout(pollEditor, 500);
+}
+function renderTools() {
+  const host = $('tools');
+  host.textContent = '';
+  if (!EDITOR || !ED) return;
+  const row = el('div', 'tool');
+  const ph = el('span', 'ph');
+  const last = el('span', 'last');
+  const acts = el('div', 'acts');
+  const name = 'Browser editor' + (ED.pixelorama ? ' (Pixelorama ' + ED.pixelorama + ')' : '');
+  if (ED.installing) {
+    const p = ED.installing;
+    ph.append(el('i', 'dot cool'), document.createTextNode('installing'));
+    last.textContent = name + ': fetching ' + (p.file || 'the build') + ' \u2014 ' + fmtMb(p.fetchedBytes) + ' of ' + fmtMb(p.totalBytes);
+    row.append(ph, last, acts);
+    const bar = el('progress');
+    if (p.totalBytes) { bar.max = p.totalBytes; bar.value = p.fetchedBytes; }
+    row.append(bar);
+  } else if (ED.installed) {
+    ph.append(el('i', 'dot ok'), document.createTextNode('ready'));
+    last.textContent = name + ' is installed and verified; a record\u2019s Hand edit section opens sprites in it.';
+    last.title = ED.dir || '';
+    const b = el('button', null, 'Open editor');
+    b.type = 'button'; b.onclick = () => window.open(ED.url, '_blank', 'noopener');
+    acts.append(b);
+    row.append(ph, last, acts);
+  } else if (ED.error) {
+    ph.append(el('i', 'dot bad'), document.createTextNode('failed'));
+    last.textContent = name + ': ' + ED.error;
+    const b = el('button', 'primary', 'Retry install');
+    b.type = 'button'; b.onclick = installEditor;
+    acts.append(b);
+    row.append(ph, last, acts);
+  } else if (!ED.release) {
+    ph.append(el('i', 'dot dim'), document.createTextNode('unavailable'));
+    last.textContent = name + ': this PixelKiln version pins no published build.';
+    row.append(ph, last, acts);
+  } else {
+    ph.append(el('i', 'dot dim'), document.createTextNode('not installed'));
+    last.textContent = name + ': ' + fmtMb(ED.totalBytes - (ED.installedBytes || 0)) + ' fetched once from the PixelKiln release ' +
+      ED.release + ', verified against the hashes this version carries, and kept outside the project.';
+    const b = el('button', 'primary', 'Install editor');
+    b.type = 'button'; b.onclick = installEditor;
+    acts.append(b);
+    row.append(ph, last, acts);
+  }
+  host.append(row);
+}
+
 function budgetLine() {
   const providers = new Set([...Object.keys(GEN.budget.byProvider), ...Object.keys(GEN.spent)]);
   const parts = [];
@@ -9442,8 +9673,169 @@ function openReview(jobId) {
   host.append(scrim, panel);
 }
 window.addEventListener('message', (e) => {
-  if (e.origin !== location.origin || !e.data || e.data.type !== 'pixelkiln:review-applied') return;
-  setTimeout(() => { $('dialog-host').textContent = ''; pollJobs(); refresh(); }, 600);
+  if (e.origin !== location.origin || !e.data || typeof e.data.type !== 'string') return;
+  if (e.data.type === 'pixelkiln:review-applied') {
+    setTimeout(() => { $('dialog-host').textContent = ''; pollJobs(); refresh(); }, 600);
+    return;
+  }
+  if (SHEET && e.source === SHEET.frame.contentWindow) onEditorMessage(e.data);
+});
+
+// ---- the in-browser editor sheet -------------------------------------------
+// The page is the protocol host: it hands the editor the PNG and palette,
+// asks it for the image back, and does the authenticated write itself. The
+// iframe never sees the session token, and the server validates, sizes, and
+// declares the file the same way pixelkiln edit does.
+
+let SHEET = null;
+const editorSource = (item) => item.edit && item.edit.exists ? item.edit
+  : item.outputs.length === 1 && item.outputs[0].exists && item.outputs[0].mediaType === 'image/png' ? item.outputs[0] : null;
+const canEditInBrowser = (item) => EDITOR && EDITABLE && item.declared && item.asset && projectOf(item)?.manifestSha256 && editorSource(item) &&
+  !(item.outputs.length > 1);
+const toBase64 = (buf) => new Promise((resolve, reject) => {
+  const r = new FileReader();
+  r.onload = () => resolve(String(r.result).slice(String(r.result).indexOf(',') + 1));
+  r.onerror = () => reject(r.error);
+  r.readAsDataURL(new Blob([buf]));
+});
+function sheetStatus(tone, text) {
+  if (!SHEET) return;
+  SHEET.status.textContent = '';
+  SHEET.status.append(el('i', 'dot ' + tone), document.createTextNode(text));
+}
+function sheetButtons() {
+  if (!SHEET) return;
+  const busy = !SHEET.opened || SHEET.pending !== null;
+  SHEET.save.disabled = busy || !SHEET.dirty;
+  SHEET.saveClose.disabled = busy;
+}
+function openEditorSheet(item) {
+  if (SHEET) return;
+  const src = editorSource(item);
+  const host = $('dialog-host');
+  host.textContent = '';
+  const scrim = el('div', 'sheet-scrim');
+  scrim.onclick = () => closeEditorSheet();
+  const panel = el('div', 'sheet editor-host');
+  const bar = el('div', 'rbar');
+  const close = el('button', null, 'Close'); close.type = 'button';
+  close.onclick = () => closeEditorSheet();
+  const title = el('b', null, (item.project ? item.project + ':' : '') + item.styleId + '/' + item.assetId + ' \xB7 ' + item.width + '\xD7' + item.height);
+  const status = el('span', 'st');
+  const acts = el('div', 'acts');
+  const msg = el('span', 'msg');
+  const save = el('button', 'primary', 'Save to project'); save.type = 'button';
+  save.onclick = () => requestEditorSave(false);
+  const saveClose = el('button', null, 'Save & close'); saveClose.type = 'button';
+  saveClose.onclick = () => requestEditorSave(true);
+  acts.append(msg, save, saveClose);
+  bar.append(close, title, status, acts);
+  const stage = el('div', 'stage');
+  const frame = el('iframe');
+  frame.title = 'Pixelorama';
+  frame.src = ED.url;
+  const loading = el('div', 'loading');
+  const loadText = el('div');
+  loadText.append(el('b', null, 'Loading the editor'), document.createTextNode('The first open compiles a 40 MB build; later opens come from the browser cache.'));
+  loading.append(loadText);
+  stage.append(frame, loading);
+  panel.append(bar, stage);
+  host.append(scrim, panel);
+  SHEET = { item, frame, loading, status, msg, save, saveClose, dirty: false, opened: false, ready: null, pending: null, requests: 0, source: src };
+  sheetStatus('cool', 'loading');
+  sheetButtons();
+  close.focus({ preventScroll: true });
+}
+async function sendOpen() {
+  const { item, source } = SHEET;
+  const style = snap.styles.find((s) => s.id === item.styleId && s.project === item.project);
+  let png;
+  try {
+    const res = await fetch(source.url, { cache: 'no-store' });
+    if (!res.ok) throw new Error(await res.text());
+    png = await res.arrayBuffer();
+  } catch (err) {
+    if (SHEET) { SHEET.msg.textContent = 'Could not load the image: ' + err.message; sheetStatus('bad', 'failed'); }
+    return;
+  }
+  if (!SHEET) return;
+  const request = 'open-' + (++SHEET.requests);
+  SHEET.frame.contentWindow.postMessage({
+    type: 'pixelkiln:open', request,
+    asset: { key: item.styleId + '/' + item.assetId, id: item.id, name: item.assetId, width: item.width, height: item.height },
+    png, palette: style ? style.palette : [],
+  }, location.origin, [png]);
+  sheetStatus('cool', 'opening');
+}
+function requestEditorSave(close) {
+  if (!SHEET || !SHEET.opened || SHEET.pending) return;
+  const request = 'save-' + (++SHEET.requests);
+  SHEET.pending = { request, close };
+  SHEET.msg.textContent = '';
+  sheetStatus('cool', 'saving');
+  sheetButtons();
+  SHEET.frame.contentWindow.postMessage({ type: 'pixelkiln:request-save', request }, location.origin);
+}
+async function onEditorMessage(m) {
+  switch (m.type) {
+    case 'pixelkiln:ready':
+      SHEET.ready = m;
+      if (m.version !== ED.protocol) {
+        SHEET.msg.textContent = 'The editor speaks protocol ' + m.version + '; this gallery expects ' + ED.protocol + '. Reinstall it with pixelkiln tools install editor.';
+        sheetStatus('bad', 'mismatch');
+        return;
+      }
+      sendOpen();
+      break;
+    case 'pixelkiln:opened':
+      SHEET.opened = true;
+      SHEET.loading.remove();
+      sheetStatus('ok', SHEET.item.edit && SHEET.item.edit.exists ? 'editing the edit file' : 'editing a copy of the generated art');
+      sheetButtons();
+      break;
+    case 'pixelkiln:dirty':
+      SHEET.dirty = !!m.dirty;
+      if (SHEET.opened && !SHEET.pending) sheetStatus(SHEET.dirty ? 'warn' : 'ok', SHEET.dirty ? 'unsaved changes' : 'saved');
+      sheetButtons();
+      break;
+    case 'pixelkiln:save': {
+      const pending = SHEET.pending;
+      if (!pending || pending.request !== m.request) return;
+      try {
+        const body = { png: await toBase64(m.png), editor: SHEET.ready.editor, protocol: SHEET.ready.version };
+        if (m.pxo && m.pxo.byteLength) body.pxo = await toBase64(m.pxo);
+        await postHandEdit(SHEET.item, 'save-edit', body);
+        const saved = snap.items.find((i) => i.id === SHEET.item.id);
+        if (saved) SHEET.item = saved;
+        SHEET.dirty = false;
+        SHEET.pending = null;
+        ui.notice = { id: SHEET.item.id, text: 'Saved ' + (saved && saved.edit ? saved.edit.path : 'the edit') + '. mount and pack place it in place of the generated art.' };
+        render();
+        if (pending.close) { closeEditorSheet(true); return; }
+        sheetStatus('ok', 'saved');
+      } catch (err) {
+        SHEET.pending = null;
+        SHEET.msg.textContent = err.message + (err.status === 409 ? ' \u2014 press Refresh, then save again.' : '');
+        sheetStatus('bad', 'not saved');
+      }
+      sheetButtons();
+      break;
+    }
+    case 'pixelkiln:error':
+      SHEET.msg.textContent = m.message || 'The editor reported an error.';
+      if (SHEET.pending) { SHEET.pending = null; sheetStatus('bad', 'not saved'); sheetButtons(); }
+      break;
+  }
+}
+function closeEditorSheet(force) {
+  if (!SHEET) return;
+  if (SHEET.dirty && !force && !confirm('Discard unsaved changes in the editor?')) return;
+  SHEET = null;
+  $('dialog-host').textContent = '';
+  refresh();
+}
+window.addEventListener('beforeunload', (e) => {
+  if (SHEET && SHEET.dirty) { e.preventDefault(); e.returnValue = ''; }
 });
 
 function visibleItems() {
@@ -10019,6 +10411,11 @@ function handEditSection(item) {
     row(dl, 'file', item.edit.path, { mono: true, copy: item.edit.absolutePath });
     if (item.edit.sha256) row(dl, 'sha256', item.edit.sha256.slice(0, 16) + '\u2026', { mono: true, copy: item.edit.sha256 });
     row(dl, 'saved', fmtWhen(item.edit.modifiedAt));
+    if (item.editMeta) {
+      row(dl, 'editor', item.editMeta.editor + ', ' + fmtWhen(item.editMeta.savedAt) + (item.editMeta.changedSince ? ' \u2014 the file changed since' : ''));
+      if (item.editMeta.basedOn) row(dl, 'based on', item.editMeta.basedOn.slice(0, 16) + '\u2026', { mono: true, copy: item.editMeta.basedOn });
+      if (item.editMeta.project) row(dl, 'layers', item.editMeta.project, { mono: true });
+    }
     s.append(dl);
   } else {
     s.append(el('div', 'state-dim', 'Touch it up in your own editor. The generated file stays untouched; the edit is a sibling file the manifest points at, and mount and pack place that instead.'));
@@ -10027,7 +10424,7 @@ function handEditSection(item) {
     const acts = el('div', 'hand-actions');
     const msg = el('span', 'msg');
     const go = async (label, action, extra, done) => {
-      const b = el('button', label === 'Detach edit' ? null : 'primary', label); b.type = 'button';
+      const b = el('button', label === 'Detach edit' || (EDITOR && ED && ED.installed) ? null : 'primary', label); b.type = 'button';
       b.onclick = async () => {
         b.disabled = true; msg.className = 'msg'; msg.textContent = '\u2026';
         try { await postHandEdit(item, action, extra); ui.notice = { id: item.id, text: done }; render(); }
@@ -10035,8 +10432,20 @@ function handEditSection(item) {
       };
       acts.append(b);
     };
+    if (EDITOR && ED && (item.edit || canStart) && editorSource(item)) {
+      if (ED.installed) {
+        const b = el('button', 'primary', 'Edit in browser'); b.type = 'button';
+        b.title = 'Open in Pixelorama here; Save writes the edit file and declares it';
+        b.onclick = () => openEditorSheet(item);
+        acts.append(b);
+      } else if (ED.release && !ED.installing) {
+        const b = el('button', null, 'Install editor to edit in browser'); b.type = 'button';
+        b.onclick = () => { installEditor(); window.scrollTo({ top: 0 }); };
+        acts.append(b);
+      }
+    }
     if (item.edit) {
-      go('Open in editor', 'start-edit', { open: true }, 'Opened ' + item.edit.path + ' in your editor. Save there, then Refresh.');
+      go('Open in desktop editor', 'start-edit', { open: true }, 'Opened ' + item.edit.path + ' in your editor. Save there, then Refresh.');
       go('Detach edit', 'detach-edit', {}, 'Detached. The file is still at ' + item.edit.path + '; the generated art is placed again.');
     } else if (canStart) {
       go('Edit by hand', 'start-edit', { open: true }, 'Created the edit file and opened it in your editor. Save there, then Refresh to see it here.');
@@ -10763,6 +11172,7 @@ document.addEventListener('keydown', (e) => {
   if (e.key === '/' && !typing) { e.preventDefault(); $('q').focus(); return; }
   if (e.key === 'Escape') {
     if (typing && document.activeElement.id === 'q') { document.activeElement.blur(); return; }
+    if (SHEET) { e.preventDefault(); closeEditorSheet(); return; }
     if ($('dialog-host').childNodes.length) { e.preventDefault(); $('dialog-host').textContent = ''; return; }
     if (ui.open) { e.preventDefault(); closeItem(); }
     return;
@@ -10784,6 +11194,7 @@ ui.compare = ui.compare.filter((id) => snap.items.some((i) => i.id === id));
 render();
 if (ui.open) document.querySelector('.card.active')?.scrollIntoView({ block: 'center' });
 if (GENERATION) pollJobs();
+if (EDITOR) pollEditor();
 if (ui.compare.length >= 2 && !ui.open) openCompare();
 </script>
 </body>
@@ -10792,7 +11203,16 @@ if (ui.compare.length >= 2 && !ui.open) openCompare();
 var escapeHtml2 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 
 // src/gallery/server.ts
-var MAX_EDIT_BYTES = 64 * 1024;
+var MAX_EDIT_BYTES = 48 * 1024 * 1024;
+var EDITOR_CSP = [
+  "default-src 'self'",
+  "script-src 'self' 'unsafe-inline' 'unsafe-eval' 'wasm-unsafe-eval'",
+  "style-src 'self' 'unsafe-inline'",
+  "img-src 'self' data: blob:",
+  "worker-src 'self' blob:",
+  "connect-src 'self'",
+  "frame-ancestors 'self'"
+].join("; ");
 async function readJsonBody(req) {
   const chunks = [];
   let bytes = 0;
@@ -10810,7 +11230,7 @@ async function readJsonBody(req) {
 async function serveGallery(opts) {
   const log2 = opts.onProgress ?? (() => {
   });
-  const session = opts.edit || opts.generate ? randomBytes(16).toString("hex") : null;
+  const session = opts.edit || opts.generate || opts.editor ? randomBytes(16).toString("hex") : null;
   let media = /* @__PURE__ */ new Map();
   let loading = null;
   const reviewAssets = /* @__PURE__ */ new Map();
@@ -10885,6 +11305,17 @@ async function serveGallery(opts) {
       }
       return;
     }
+    if (req.method === "POST" && url2.pathname === "/api/editor/install") {
+      if (!opts.editor || !session) return fail(405, "the in-browser editor is off for this gallery");
+      try {
+        const body = await guardedBody("editor installs");
+        if (body === void 0) return;
+        json(202, await opts.editor.install());
+      } catch (err) {
+        reportError("editor install", err);
+      }
+      return;
+    }
     const reviewMatch = /^\/review\/([0-9a-f]{16})(\/.*)?$/.exec(url2.pathname);
     if (reviewMatch && opts.generate) {
       const [, jobId, rest = ""] = reviewMatch;
@@ -10930,7 +11361,7 @@ async function serveGallery(opts) {
         const asset = reviewAssets.get(jobId)?.get(url2.pathname);
         if (!asset) return fail(404, "no such review asset");
         try {
-          const bytes = await readFile16(asset.path);
+          const bytes = await readFile17(asset.path);
           res.writeHead(200, {
             "Content-Type": asset.contentType,
             "Cache-Control": "no-store",
@@ -10948,6 +11379,32 @@ async function serveGallery(opts) {
       if (!opts.generate) return fail(404, "generation is off");
       return json(200, opts.generate.status());
     }
+    if (url2.pathname === "/api/editor") {
+      if (!opts.editor) return fail(404, "the in-browser editor is off for this gallery");
+      try {
+        return json(200, await opts.editor.status());
+      } catch (err) {
+        return reportError("editor status", err);
+      }
+    }
+    const editorMatch = /^\/editor\/([A-Za-z0-9._-]+)\/([A-Za-z0-9._-]+)$/.exec(url2.pathname);
+    if (editorMatch) {
+      if (!opts.editor) return fail(404, "the in-browser editor is off for this gallery");
+      const file = await opts.editor.file(editorMatch[1], editorMatch[2]);
+      if (!file) return fail(404, "that editor file is not installed; check /api/editor");
+      res.writeHead(200, {
+        "Content-Type": file.contentType,
+        "Content-Length": file.bytes.length,
+        // The release tag is in the path, so these bytes never change under
+        // this URL; the 40 MB wasm should come from the browser cache.
+        "Cache-Control": "public, max-age=31536000, immutable",
+        "X-Content-Type-Options": "nosniff",
+        "Cross-Origin-Resource-Policy": "same-origin",
+        ...editorMatch[2] === "index.html" ? { "Content-Security-Policy": EDITOR_CSP } : {}
+      });
+      res.end(req.method === "HEAD" ? void 0 : file.bytes);
+      return;
+    }
     try {
       if (url2.pathname === "/") {
         const { snapshot } = await load();
@@ -10959,7 +11416,8 @@ async function serveGallery(opts) {
         res.end(renderGallery(snapshot, {
           ...session ? { session } : {},
           editable: Boolean(opts.edit),
-          generation: Boolean(opts.generate)
+          generation: Boolean(opts.generate),
+          editor: Boolean(opts.editor)
         }));
         return;
       }
@@ -10979,7 +11437,7 @@ async function serveGallery(opts) {
         if (!asset) return fail(404, "no such gallery media");
         let bytes;
         try {
-          bytes = await readFile16(asset.path);
+          bytes = await readFile17(asset.path);
         } catch {
           return fail(404, "gallery media is no longer on disk; refresh the page");
         }
@@ -11025,16 +11483,16 @@ async function serveGallery(opts) {
 
 // src/gallery/generate.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { z as z7 } from "zod";
-var GenerateRequestSchema = z7.object({
-  project: z7.string().min(1).optional(),
-  keys: z7.array(z7.string().min(1)).min(1).max(500),
+import { z as z8 } from "zod";
+var GenerateRequestSchema = z8.object({
+  project: z8.string().min(1).optional(),
+  keys: z8.array(z8.string().min(1)).min(1).max(500),
   /** Regenerate work that is up to date, as `gen --force` does. */
-  force: z7.boolean().optional(),
+  force: z8.boolean().optional(),
   /** Advance in-flight, review, or selected work without submitting anything. */
-  resume: z7.boolean().optional(),
+  resume: z8.boolean().optional(),
   /** Re-download downloaded outputs and replace files whose object changed upstream. */
-  refresh: z7.boolean().optional()
+  refresh: z8.boolean().optional()
 }).strict().refine((request) => !(request.resume && request.refresh), { message: "resume and refresh are exclusive" });
 var GenerateRequestError = class extends Error {
   constructor(message6, status = 400) {
@@ -11288,20 +11746,318 @@ function createGenerateHandlers(opts) {
   };
 }
 
-// src/pipeline/salvage.ts
-import { readFile as readFile17 } from "fs/promises";
+// src/gallery/editor.ts
+import { readFile as readFile19 } from "fs/promises";
+import path24 from "path";
+
+// src/editor/install.ts
+import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync18 } from "fs";
+import { mkdir as mkdir7, readFile as readFile18, rename as rename8, rm as rm9, stat as stat4, writeFile as writeFile10 } from "fs/promises";
+import os2 from "os";
 import path23 from "path";
+
+// tools/pixelorama-bridge/pin.json
+var pin_default = {
+  pixelorama: "v1.2.2",
+  godot: "4.7.2",
+  extensionsApi: 9,
+  protocol: 1,
+  release: "editor-pixelorama-v1.2.2-pk.6",
+  files: {
+    "index.apple-touch-icon.png": {
+      sha256: "ee5434873e0fed91e9a888c3ea5a8b79beac25999308be7a6eb41bf4ce640d27",
+      bytes: 1036
+    },
+    "index.audio.position.worklet.js": {
+      sha256: "be33985bc7160d6bf9646f259cd86b259cd67b02ccb297ee5c44f8ac84327bc8",
+      bytes: 2973
+    },
+    "index.audio.worklet.js": {
+      sha256: "5b476a9c9ce642c0ee4256436d1bc31d9c38f868aca0f9a8e2a57c18d2dec2a3",
+      bytes: 7298
+    },
+    "index.html": {
+      sha256: "43299b159b780809044fc0a484906bb93a280116c22cc87388ee2ab8263ac1f3",
+      bytes: 5442
+    },
+    "index.icon.png": {
+      sha256: "42a327d23178ddc26cc97e3560ebca6bc7c575d2a1b12a4837f2462049ca5745",
+      bytes: 1070
+    },
+    "index.js": {
+      sha256: "33c94cb3175f3333b82e2a3be5e8e86f77986f0aa2042b1631f6367a4e5bb6ba",
+      bytes: 279815
+    },
+    "index.pck": {
+      sha256: "ee10aa3d6e09a1ff2a334d0de7df1ae57f32ce00698948892a46443c2c67ae7a",
+      bytes: 6426700
+    },
+    "index.png": {
+      sha256: "6e3ca3eb4a99e4c07bdd89ebc873b440ec0ffd66ce1955160da9e7ed80d538d7",
+      bytes: 13558
+    },
+    "index.wasm": {
+      sha256: "fc74679e3b97f76878947fcd4fbe1268cbfa6188182a2e33bbc3f5dc9bfa57d0",
+      bytes: 39514754
+    }
+  }
+};
+
+// src/editor/pin.ts
+var EDITOR_PIN = pin_default;
+var EDITOR_RELEASE_BASE = "https://github.com/gfargo/pixelkiln/releases/download";
+
+// src/editor/install.ts
+var EditorInstallError = class extends Error {
+  constructor(message6, file) {
+    super(message6);
+    this.file = file;
+    this.name = "EditorInstallError";
+  }
+  file;
+};
+function editorToolsRoot() {
+  const override = process.env.PIXELKILN_TOOLS_DIR?.trim();
+  if (override) return path23.resolve(override);
+  if (process.platform === "darwin") return path23.join(os2.homedir(), "Library", "Caches", "pixelkiln", "tools");
+  if (process.platform === "win32") {
+    return path23.join(process.env.LOCALAPPDATA ?? path23.join(os2.homedir(), "AppData", "Local"), "pixelkiln", "tools");
+  }
+  return path23.join(process.env.XDG_CACHE_HOME ?? path23.join(os2.homedir(), ".cache"), "pixelkiln", "tools");
+}
+function editorDir(pin = EDITOR_PIN, root = editorToolsRoot()) {
+  return path23.join(root, "pixelorama", pin.release ?? "unpublished");
+}
+function editorBaseUrl(pin = EDITOR_PIN) {
+  const override = process.env.PIXELKILN_EDITOR_URL?.trim();
+  if (override) return override.replace(/\/+$/, "");
+  if (!pin.release) return null;
+  return `${EDITOR_RELEASE_BASE}/${encodeURIComponent(pin.release)}`;
+}
+async function sha256Of(file) {
+  try {
+    return createHash4("sha256").update(await readFile18(file)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+async function editorStatus(opts = {}) {
+  const pin = opts.pin ?? EDITOR_PIN;
+  const dir = opts.dir ?? editorDir(pin);
+  const missing = [];
+  let installedBytes = 0;
+  let totalBytes = 0;
+  for (const [name, expected] of Object.entries(pin.files)) {
+    totalBytes += expected.bytes;
+    const file = path23.join(dir, name);
+    const info = existsSync18(file) ? await stat4(file).catch(() => null) : null;
+    if (info && info.size === expected.bytes && await sha256Of(file) === expected.sha256) {
+      installedBytes += expected.bytes;
+    } else {
+      missing.push(name);
+    }
+  }
+  const pinned = Object.keys(pin.files).length > 0 && pin.release !== null;
+  return {
+    release: pin.release,
+    dir,
+    installed: pinned && missing.length === 0,
+    missing: pinned ? missing : Object.keys(pin.files),
+    totalBytes,
+    installedBytes
+  };
+}
+async function installEditor(opts = {}) {
+  const pin = opts.pin ?? EDITOR_PIN;
+  const dir = opts.dir ?? editorDir(pin);
+  const baseUrl = opts.baseUrl ?? editorBaseUrl(pin);
+  const doFetch = opts.fetch ?? fetch;
+  const before = await editorStatus({ pin, dir });
+  if (!pin.release || !Object.keys(pin.files).length) {
+    throw new EditorInstallError(
+      "this PixelKiln version pins no published editor build; upgrade, or set PIXELKILN_EDITOR_URL to a build you trust"
+    );
+  }
+  if (!baseUrl) throw new EditorInstallError("no download location for the editor build");
+  await mkdir7(dir, { recursive: true });
+  const downloaded = [];
+  const skipped = Object.keys(pin.files).filter((name) => !before.missing.includes(name));
+  let fetchedBytes = before.installedBytes;
+  const names = before.missing;
+  for (const [index, name] of names.entries()) {
+    const expected = pin.files[name];
+    const report = (phase, received) => opts.onProgress?.({
+      file: name,
+      index,
+      count: names.length,
+      bytes: expected.bytes,
+      totalBytes: before.totalBytes,
+      fetchedBytes: fetchedBytes + received,
+      phase
+    });
+    report("start", 0);
+    const url = `${baseUrl}/${encodeURIComponent(name)}`;
+    const response = await doFetch(url, { signal: opts.signal, redirect: "follow" });
+    if (!response.ok) throw new EditorInstallError(`${name}: ${response.status} ${response.statusText} from ${url}`, name);
+    const bytes = await readBody(response, expected.bytes, (received) => report("progress", received));
+    if (bytes.length !== expected.bytes) {
+      throw new EditorInstallError(`${name}: expected ${expected.bytes} bytes, got ${bytes.length}`, name);
+    }
+    const digest2 = createHash4("sha256").update(bytes).digest("hex");
+    if (digest2 !== expected.sha256) {
+      throw new EditorInstallError(`${name}: sha256 ${digest2.slice(0, 12)}\u2026 does not match the pinned ${expected.sha256.slice(0, 12)}\u2026`, name);
+    }
+    const final = path23.join(dir, name);
+    const tmp = `${final}.${process.pid}.part`;
+    try {
+      await writeFile10(tmp, bytes);
+      await rename8(tmp, final);
+    } finally {
+      await rm9(tmp, { force: true });
+    }
+    fetchedBytes += bytes.length;
+    downloaded.push(name);
+    report("done", 0);
+  }
+  const after = await editorStatus({ pin, dir });
+  if (!after.installed) {
+    throw new EditorInstallError(`editor install is incomplete: ${after.missing.join(", ")}`);
+  }
+  return { ...after, downloaded, skipped };
+}
+async function readBody(response, expectedBytes, onBytes) {
+  if (!response.body) return Buffer.from(await response.arrayBuffer());
+  const chunks = [];
+  let received = 0;
+  const reader = response.body.getReader();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    received += value.length;
+    if (received > expectedBytes) {
+      await reader.cancel().catch(() => {
+      });
+      break;
+    }
+    onBytes(received);
+  }
+  return Buffer.concat(chunks);
+}
+var EDITOR_CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".wasm": "application/wasm",
+  ".pck": "application/octet-stream",
+  ".png": "image/png",
+  ".json": "application/json; charset=utf-8"
+};
+function editorContentType(name) {
+  return EDITOR_CONTENT_TYPES[path23.extname(name).toLowerCase()] ?? null;
+}
+
+// src/gallery/editor.ts
+function editorRoute(release, name = "index.html") {
+  return `/editor/${encodeURIComponent(release)}/${encodeURIComponent(name)}`;
+}
+function createGalleryEditorHandlers(opts = {}) {
+  const pin = opts.pin ?? EDITOR_PIN;
+  const dir = opts.dir ?? editorDir(pin);
+  const log2 = opts.onProgress ?? (() => {
+  });
+  let verified = null;
+  let checking = null;
+  let installing = null;
+  let running = null;
+  let error = null;
+  const check = () => {
+    if (!checking) {
+      checking = editorStatus({ pin, dir }).then((status) => {
+        verified = status;
+        return status;
+      }).finally(() => {
+        checking = null;
+      });
+    }
+    return checking;
+  };
+  const describe = (status) => ({
+    ...status,
+    pixelorama: pin.pixelorama,
+    protocol: pin.protocol,
+    url: status.installed && pin.release ? editorRoute(pin.release) : null,
+    installing,
+    error
+  });
+  return {
+    release: pin.release,
+    status: async () => describe(verified ?? await check()),
+    install: async () => {
+      if (!running) {
+        error = null;
+        installing = { file: "", index: 0, count: 0, bytes: 0, totalBytes: 0, fetchedBytes: 0, phase: "start" };
+        log2(`  installing the editor (Pixelorama ${pin.pixelorama}) into ${dir}`);
+        running = installEditor({
+          pin,
+          dir,
+          baseUrl: opts.baseUrl ?? editorBaseUrl(pin) ?? void 0,
+          ...opts.fetch ? { fetch: opts.fetch } : {},
+          onProgress: (progress) => {
+            installing = progress;
+          }
+        }).then((result) => {
+          verified = result;
+          const mb = (result.totalBytes / 1e6).toFixed(1);
+          log2(`  editor ready: ${result.downloaded.length} file(s) fetched, ${result.skipped.length} already present (${mb} MB)`);
+        }).catch((err) => {
+          error = err instanceof Error ? err.message : String(err);
+          verified = null;
+          log2(`  editor install failed: ${error}`);
+        }).finally(() => {
+          installing = null;
+          running = null;
+        });
+      }
+      return describe(verified ?? await check());
+    },
+    file: async (release, name) => {
+      if (!pin.release || release !== pin.release) return null;
+      const expected = pin.files[name];
+      const contentType = editorContentType(name);
+      if (!expected || !contentType) return null;
+      const status = verified ?? await check();
+      if (!status.installed) return null;
+      let bytes;
+      try {
+        bytes = await readFile19(path24.join(dir, name));
+      } catch {
+        verified = null;
+        return null;
+      }
+      if (bytes.length !== expected.bytes) {
+        verified = null;
+        return null;
+      }
+      return { bytes, contentType };
+    }
+  };
+}
+
+// src/pipeline/salvage.ts
+import { readFile as readFile20 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import path25 from "path";
 function providerClaimId(provider, objectId) {
   return `${encodeURIComponent(provider)}:${encodeURIComponent(objectId)}`;
 }
 async function loadClaims(lockPaths, opts = {}) {
   const claimed = /* @__PURE__ */ new Set();
   for (const p of lockPaths) {
-    if (!existsSync18(p)) throw new Error(`Claim lockfile not found: ${p}`);
+    if (!existsSync19(p)) throw new Error(`Claim lockfile not found: ${p}`);
     let parsed;
     try {
-      parsed = parseLock(JSON.parse(await readFile17(p, "utf8")));
+      parsed = parseLock(JSON.parse(await readFile20(p, "utf8")));
     } catch {
       throw new Error(`Claim lockfile is malformed: ${p}`);
     }
@@ -11349,20 +12105,20 @@ function matchStyleByPattern(prompt, manifest) {
   return null;
 }
 async function loadSiblingManifests(ownManifestPath, workspaceManifestPaths, claimPaths) {
-  const own = path23.resolve(ownManifestPath);
+  const own = path25.resolve(ownManifestPath);
   const siblingManifestPaths = [
     .../* @__PURE__ */ new Set([
       ...workspaceManifestPaths,
-      ...claimPaths.map((c) => path23.join(path23.dirname(path23.resolve(c)), "pixelkiln.manifest.json"))
+      ...claimPaths.map((c) => path25.join(path25.dirname(path25.resolve(c)), "pixelkiln.manifest.json"))
     ])
   ];
   const siblings = [];
   for (const siblingManifestPath of siblingManifestPaths) {
-    if (path23.resolve(siblingManifestPath) === own) continue;
-    if (!existsSync18(siblingManifestPath)) continue;
+    if (path25.resolve(siblingManifestPath) === own) continue;
+    if (!existsSync19(siblingManifestPath)) continue;
     try {
       const { manifest } = await loadManifest(siblingManifestPath);
-      siblings.push({ label: path23.basename(path23.dirname(siblingManifestPath)), manifest });
+      siblings.push({ label: path25.basename(path25.dirname(siblingManifestPath)), manifest });
     } catch {
     }
   }
@@ -11581,15 +12337,15 @@ async function workspaceStatus(ws, dir) {
 }
 
 // src/pipeline/cache-health.ts
-import { existsSync as existsSync19 } from "fs";
-import { readFile as readFile18, readdir as readdir2, rm as rm8 } from "fs/promises";
-import path24 from "path";
+import { existsSync as existsSync20 } from "fs";
+import { readFile as readFile21, readdir as readdir2, rm as rm10 } from "fs/promises";
+import path26 from "path";
 async function inspectCaches(lock, lockPath, options = {}) {
-  if (options.prune && !existsSync19(lockPath)) {
-    throw new Error(`Refusing to prune without an existing lockfile at ${path24.resolve(lockPath)}`);
+  if (options.prune && !existsSync20(lockPath)) {
+    throw new Error(`Refusing to prune without an existing lockfile at ${path26.resolve(lockPath)}`);
   }
-  const contentDir = path24.resolve(path24.dirname(lockPath), ".pixelkiln", "cache");
-  const remotePath = path24.resolve(cachePathFor(lockPath));
+  const contentDir = path26.resolve(path26.dirname(lockPath), ".pixelkiln", "cache");
+  const remotePath = path26.resolve(cachePathFor(lockPath));
   const referenced = new Set(
     Object.values(lock.entries).flatMap((entry) => entry.outputs.map((output) => output.sha256))
   );
@@ -11603,7 +12359,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
     ]);
     for (const name of names) {
       try {
-        await rm8(path24.join(contentDir, name), { force: true });
+        await rm10(path26.join(contentDir, name), { force: true });
         removed.contentFiles++;
       } catch {
       }
@@ -11612,7 +12368,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 readFile18(remotePath, "utf8")));
+      const cache = parseCache(JSON.parse(await readFile21(remotePath, "utf8")));
       for (const id of remoteHashes.invalidIds) delete cache.hashes[id];
       removed.remoteHashEntries = remoteHashes.invalidIds.length;
       await saveCache(remotePath, cache);
@@ -11630,7 +12386,7 @@ async function inspectCaches(lock, lockPath, options = {}) {
 async function inspectContentCache(contentDir, referenced) {
   const report = {
     path: contentDir,
-    exists: existsSync19(contentDir),
+    exists: existsSync20(contentDir),
     files: 0,
     bytes: 0,
     valid: 0,
@@ -11651,12 +12407,12 @@ async function inspectContentCache(contentDir, referenced) {
       continue;
     }
     report.files++;
-    const file = path24.join(contentDir, entry.name);
+    const file = path26.join(contentDir, entry.name);
     const mediaType = mediaTypeFromExtension(entry.name);
     const expected = mediaType ? entry.name.slice(0, -4) : "";
     let bytes;
     try {
-      bytes = await readFile18(file);
+      bytes = await readFile21(file);
       report.bytes += bytes.length;
     } catch (err) {
       report.invalid.push({
@@ -11694,7 +12450,7 @@ async function inspectContentCache(contentDir, referenced) {
 async function inspectRemoteHashCache(remotePath) {
   const report = {
     path: remotePath,
-    exists: existsSync19(remotePath),
+    exists: existsSync20(remotePath),
     entries: 0,
     valid: 0,
     invalidIds: [],
@@ -11703,7 +12459,7 @@ async function inspectRemoteHashCache(remotePath) {
   if (!report.exists) return report;
   let cache;
   try {
-    cache = parseCache(JSON.parse(await readFile18(remotePath, "utf8")));
+    cache = parseCache(JSON.parse(await readFile21(remotePath, "utf8")));
   } catch (err) {
     report.error = err instanceof Error ? err.message : String(err);
     return report;
@@ -11974,8 +12730,8 @@ function isRecord2(value) {
 }
 
 // src/pick/salvage-server.ts
-import { mkdir as mkdir7, writeFile as writeFile9, readFile as readFile19 } from "fs/promises";
-import path25 from "path";
+import { mkdir as mkdir8, writeFile as writeFile11, readFile as readFile22 } from "fs/promises";
+import path27 from "path";
 
 // src/pick/salvage-sheet.ts
 var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
@@ -12140,7 +12896,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
   });
   const html = renderSalvageSheet(orphans, {
     styleId: ctx.styleId,
-    importDir: path25.relative(process.cwd(), ctx.importDir) || "."
+    importDir: path27.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]));
@@ -12169,10 +12925,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 = path25.join("_salvaged", `${assetId}.png`);
-            const outFile = path25.resolve(ctx.importDir, rel);
-            await mkdir7(path25.dirname(outFile), { recursive: true });
-            await writeFile9(outFile, buf);
+            const rel = path27.join("_salvaged", `${assetId}.png`);
+            const outFile = path27.resolve(ctx.importDir, rel);
+            await mkdir8(path27.dirname(outFile), { recursive: true });
+            await writeFile11(outFile, buf);
             ctx.manifest.assets[assetId] = {
               prompt: orphan.prompt,
               promptByStyle: {},
@@ -12204,7 +12960,7 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
               sourceUrl: durableSource,
               sourceUrls: durableSource ? [{ url: durableSource }] : [],
               outputs: [{
-                path: portableOutputPath(outFile, path25.dirname(ctx.manifestPath)),
+                path: portableOutputPath(outFile, path27.dirname(ctx.manifestPath)),
                 sha256: sha256(buf)
               }],
               submittedAt: orphan.createdAt,
@@ -12228,9 +12984,9 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
         }
       }
       await applyTags(provider, decisions, existingTags, { onProgress: log2 });
-      const raw = JSON.parse(await readFile19(ctx.manifestPath, "utf8"));
+      const raw = JSON.parse(await readFile22(ctx.manifestPath, "utf8"));
       for (const id of importedAssetIds) raw.assets[id] = ctx.manifest.assets[id];
-      await writeFile9(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
+      await writeFile11(ctx.manifestPath, JSON.stringify(raw, null, 2) + "\n");
       await saveLock(ctx.lockPath, ctx.lock);
       return result;
     }
@@ -12238,51 +12994,51 @@ async function runSalvage(provider, orphans, ctx, opts = {}) {
 }
 
 // src/recipes.ts
-import path26 from "path";
-import { existsSync as existsSync20 } from "fs";
-import { readdir as readdir3, readFile as readFile20 } from "fs/promises";
+import path28 from "path";
+import { existsSync as existsSync21 } from "fs";
+import { readdir as readdir3, readFile as readFile23 } from "fs/promises";
 import { fileURLToPath } from "url";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var SHA256_RE = /^[0-9a-f]{64}$/;
 var RECIPE_ID_RE = /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
 var VERSION_RE = /^\d+\.\d+\.\d+$/;
 var RECIPE_FILE = "pixelkiln.recipe.json";
 var RECIPE_DIR_TOKEN = "{{recipeDir}}";
-var PortablePathSchema = z8.string().min(1).refine((value) => {
-  if (value.includes("\\") || path26.posix.isAbsolute(value)) return false;
+var PortablePathSchema = z9.string().min(1).refine((value) => {
+  if (value.includes("\\") || path28.posix.isAbsolute(value)) return false;
   const parts = value.split("/");
   return !parts.includes("") && !parts.includes(".") && !parts.includes("..");
 }, "expected a portable relative path without '.', '..', or backslashes");
-var RecipeBindingSchema = z8.object({
-  nodeId: z8.string().min(1),
-  input: z8.string().min(1)
+var RecipeBindingSchema = z9.object({
+  nodeId: z9.string().min(1),
+  input: z9.string().min(1)
 }).strict();
-var RecipeSchema = z8.object({
-  $schema: z8.string().url().optional(),
-  format: z8.literal("pixelkiln-recipe"),
-  schemaVersion: z8.literal(1),
-  id: z8.string().regex(RECIPE_ID_RE, "expected provider/name"),
-  version: z8.string().regex(VERSION_RE, "expected x.y.z"),
-  provider: z8.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  summary: z8.string().min(1).max(240),
-  files: z8.array(z8.object({
+var RecipeSchema = z9.object({
+  $schema: z9.string().url().optional(),
+  format: z9.literal("pixelkiln-recipe"),
+  schemaVersion: z9.literal(1),
+  id: z9.string().regex(RECIPE_ID_RE, "expected provider/name"),
+  version: z9.string().regex(VERSION_RE, "expected x.y.z"),
+  provider: z9.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  summary: z9.string().min(1).max(240),
+  files: z9.array(z9.object({
     path: PortablePathSchema,
-    role: z8.enum(["workflow", "reference"]),
-    sha256: z8.string().regex(SHA256_RE)
+    role: z9.enum(["workflow", "reference"]),
+    sha256: z9.string().regex(SHA256_RE)
   }).strict()).default([]),
-  models: z8.array(z8.object({
+  models: z9.array(z9.object({
     path: PortablePathSchema,
-    sha256: z8.string().regex(SHA256_RE),
-    source: z8.string().url(),
-    license: z8.string().min(1)
+    sha256: z9.string().regex(SHA256_RE),
+    source: z9.string().url(),
+    license: z9.string().min(1)
   }).strict()).default([]),
-  styleId: z8.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  styleId: z9.string().regex(/^[a-z0-9][a-z0-9-]*$/),
   style: StyleSchema,
-  workflow: z8.object({
+  workflow: z9.object({
     path: PortablePathSchema,
-    outputNodeId: z8.string().min(1),
-    numImages: z8.number().int().min(1).max(16),
-    bindings: z8.object({
+    outputNodeId: z9.string().min(1),
+    numImages: z9.number().int().min(1).max(16),
+    bindings: z9.object({
       prompt: RecipeBindingSchema,
       width: RecipeBindingSchema.optional(),
       height: RecipeBindingSchema.optional(),
@@ -12293,67 +13049,67 @@ var RecipeSchema = z8.object({
       strength: RecipeBindingSchema.optional()
     }).strict()
   }).strict().optional(),
-  quality: z8.object({
-    stage: z8.enum(["composition-source", "production-candidate"]),
-    workingCanvas: z8.object({
-      width: z8.number().int().min(16),
-      height: z8.number().int().min(16)
+  quality: z9.object({
+    stage: z9.enum(["composition-source", "production-candidate"]),
+    workingCanvas: z9.object({
+      width: z9.number().int().min(16),
+      height: z9.number().int().min(16)
     }).strict(),
-    recommendedNativeSize: z8.object({
-      min: z8.number().int().min(1),
-      max: z8.number().int().min(1)
+    recommendedNativeSize: z9.object({
+      min: z9.number().int().min(1),
+      max: z9.number().int().min(1)
     }).strict(),
-    paletteColors: z8.object({
-      min: z8.number().int().min(1),
-      max: z8.number().int().min(1)
+    paletteColors: z9.object({
+      min: z9.number().int().min(1),
+      max: z9.number().int().min(1)
     }).strict(),
-    background: z8.enum(["opaque", "transparent", "full-bleed"]),
-    checks: z8.array(z8.enum([
+    background: z9.enum(["opaque", "transparent", "full-bleed"]),
+    checks: z9.array(z9.enum([
       "prompt-coverage",
       "native-grid",
       "final-palette",
       "alpha-edge",
       "human-1x"
     ])).min(1),
-    notes: z8.array(z8.string().min(1)).default([])
+    notes: z9.array(z9.string().min(1)).default([])
   }).strict(),
-  integrity: z8.object({
-    algorithm: z8.literal("sha256"),
-    digest: z8.string().regex(SHA256_RE)
+  integrity: z9.object({
+    algorithm: z9.literal("sha256"),
+    digest: z9.string().regex(SHA256_RE)
   }).strict()
 }).strict().superRefine((recipe, context) => {
   if (recipe.style.provider && recipe.style.provider !== recipe.provider) {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       path: ["style", "provider"],
       message: "must match the recipe provider"
     });
   }
   const filePaths = recipe.files.map((file) => file.path);
   if (new Set(filePaths).size !== filePaths.length) {
-    context.addIssue({ code: z8.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
+    context.addIssue({ code: z9.ZodIssueCode.custom, path: ["files"], message: "duplicate file path" });
   }
   const modelPaths = recipe.models.map((model) => model.path);
   if (new Set(modelPaths).size !== modelPaths.length) {
-    context.addIssue({ code: z8.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
+    context.addIssue({ code: z9.ZodIssueCode.custom, path: ["models"], message: "duplicate model path" });
   }
   if (filePaths.includes(RECIPE_FILE)) {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       path: ["files"],
       message: `${RECIPE_FILE} cannot hash itself`
     });
   }
   if (recipe.quality.recommendedNativeSize.min > recipe.quality.recommendedNativeSize.max) {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       path: ["quality", "recommendedNativeSize"],
       message: "min cannot exceed max"
     });
   }
   if (recipe.quality.paletteColors.min > recipe.quality.paletteColors.max) {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       path: ["quality", "paletteColors"],
       message: "min cannot exceed max"
     });
@@ -12362,7 +13118,7 @@ var RecipeSchema = z8.object({
     (file) => file.path === recipe.workflow.path && file.role === "workflow"
   )) {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       path: ["workflow", "path"],
       message: "must name a file whose role is workflow"
     });
@@ -12370,7 +13126,7 @@ var RecipeSchema = z8.object({
   if (recipe.provider === "comfyui") {
     if (!recipe.workflow) {
       context.addIssue({
-        code: z8.ZodIssueCode.custom,
+        code: z9.ZodIssueCode.custom,
         path: ["workflow"],
         message: "ComfyUI recipes require workflow metadata"
       });
@@ -12379,7 +13135,7 @@ var RecipeSchema = z8.object({
     const options = recipe.style.providerOptions.comfyui;
     if (!options || typeof options !== "object" || Array.isArray(options)) {
       context.addIssue({
-        code: z8.ZodIssueCode.custom,
+        code: z9.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "ComfyUI recipes require ComfyUI provider options"
       });
@@ -12393,7 +13149,7 @@ var RecipeSchema = z8.object({
     };
     if (JSON.stringify(canonical3(options)) !== JSON.stringify(canonical3(expected))) {
       context.addIssue({
-        code: z8.ZodIssueCode.custom,
+        code: z9.ZodIssueCode.custom,
         path: ["style", "providerOptions", "comfyui"],
         message: "must match workflow metadata and use {{recipeDir}} for workflowFile"
       });
@@ -12425,10 +13181,10 @@ function message4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function readRecipeFile(recipePath, bundled) {
-  const absolute = path26.resolve(recipePath);
+  const absolute = path28.resolve(recipePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile20(absolute, "utf8"));
+    raw = JSON.parse(await readFile23(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read recipe ${absolute}: ${message4(error)}`, { cause: error });
   }
@@ -12439,13 +13195,13 @@ async function readRecipeFile(recipePath, bundled) {
 ` + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
     );
   }
-  return { recipe: parsed.data, path: absolute, dir: path26.dirname(absolute), bundled };
+  return { recipe: parsed.data, path: absolute, dir: path28.dirname(absolute), bundled };
 }
 async function walkRecipeFiles(root) {
-  if (!existsSync20(root)) return [];
+  if (!existsSync21(root)) return [];
   const out = [];
   for (const entry of await readdir3(root, { withFileTypes: true })) {
-    const resolved = path26.join(root, entry.name);
+    const resolved = path28.join(root, entry.name);
     if (entry.isDirectory()) out.push(...await walkRecipeFiles(resolved));
     else if (entry.isFile() && entry.name === RECIPE_FILE) out.push(resolved);
   }
@@ -12456,7 +13212,7 @@ function bundledRecipeRoot() {
 }
 async function listBundledRecipes(root = bundledRecipeRoot()) {
   const recipes = await Promise.all(
-    (await walkRecipeFiles(path26.resolve(root))).map((file) => readRecipeFile(file, true))
+    (await walkRecipeFiles(path28.resolve(root))).map((file) => readRecipeFile(file, true))
   );
   return recipes.sort(
     (a, b) => a.recipe.id.localeCompare(b.recipe.id) || compareVersions(b.recipe.version, a.recipe.version)
@@ -12479,9 +13235,9 @@ function parseSelector(selector) {
   return { id: match[1], version: match[2] };
 }
 async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
-  const local = path26.resolve(target);
-  if (existsSync20(local)) {
-    const recipePath = path26.basename(local) === RECIPE_FILE ? local : path26.join(local, RECIPE_FILE);
+  const local = path28.resolve(target);
+  if (existsSync21(local)) {
+    const recipePath = path28.basename(local) === RECIPE_FILE ? local : path28.join(local, RECIPE_FILE);
     return readRecipeFile(recipePath, false);
   }
   if (target.startsWith(".") || target.startsWith("/") || target.includes("\\")) {
@@ -12495,8 +13251,8 @@ async function resolveRecipe(target, bundledRoot = bundledRecipeRoot()) {
   return matches[0];
 }
 async function verifyFile(root, file) {
-  const absolute = path26.resolve(root, ...file.path.split("/"));
-  if (!existsSync20(absolute)) {
+  const absolute = path28.resolve(root, ...file.path.split("/"));
+  if (!existsSync21(absolute)) {
     return { path: file.path, expectedSha256: file.sha256, actualSha256: null, status: "missing" };
   }
   const actualSha256 = await sha256File(absolute);
@@ -12511,7 +13267,7 @@ async function verifyRecipe(target, options = {}) {
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const actualIntegrity = recipeDigest(loaded.recipe);
   const files = await Promise.all(loaded.recipe.files.map((file) => verifyFile(loaded.dir, file)));
-  const modelRoot = options.modelRoot ? path26.resolve(options.modelRoot) : null;
+  const modelRoot = options.modelRoot ? path28.resolve(options.modelRoot) : null;
   const models = modelRoot ? await Promise.all(loaded.recipe.models.map(async (model) => ({
     ...await verifyFile(modelRoot, model),
     source: model.source,
@@ -12545,7 +13301,7 @@ async function verifyRecipe(target, options = {}) {
   };
 }
 function renderStyle(style, destination, cwd) {
-  const portableDir = path26.relative(cwd, destination).split(path26.sep).join("/") || ".";
+  const portableDir = path28.relative(cwd, destination).split(path28.sep).join("/") || ".";
   const replace = (value) => {
     if (typeof value === "string") return value.replaceAll(RECIPE_DIR_TOKEN, portableDir);
     if (Array.isArray(value)) return value.map(replace);
@@ -12557,25 +13313,25 @@ function renderStyle(style, destination, cwd) {
   return replace(style);
 }
 async function installRecipe(target, options = {}) {
-  const cwd = path26.resolve(options.cwd ?? process.cwd());
+  const cwd = path28.resolve(options.cwd ?? process.cwd());
   const loaded = await resolveRecipe(target, options.bundledRoot);
   const verification = await verifyRecipe(loaded.path);
   if (!verification.ok) {
     throw new Error(`Recipe ${loaded.recipe.id}@${loaded.recipe.version} failed integrity verification.`);
   }
-  const destination = options.out ? path26.resolve(cwd, options.out) : path26.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
+  const destination = options.out ? path28.resolve(cwd, options.out) : path28.join(cwd, "pixelkiln-recipes", ...loaded.recipe.id.split("/"), loaded.recipe.version);
   const sources = [
     { path: RECIPE_FILE, source: loaded.path },
-    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path26.join(loaded.dir, ...file.path.split("/")) }))
+    ...loaded.recipe.files.map((file) => ({ path: file.path, source: path28.join(loaded.dir, ...file.path.split("/")) }))
   ];
   const files = await Promise.all(sources.map(async (file) => ({
-    path: path26.join(destination, ...file.path.split("/")),
-    data: await readFile20(file.source)
+    path: path28.join(destination, ...file.path.split("/")),
+    data: await readFile23(file.source)
   })));
   if (!options.force) {
     for (const file of files) {
-      if (!existsSync20(file.path)) continue;
-      const current = await readFile20(file.path);
+      if (!existsSync21(file.path)) continue;
+      const current = await readFile23(file.path);
       if (!current.equals(file.data)) {
         throw new Error(
           `Recipe destination has local changes: ${file.path}. Choose another --out or pass --force to replace declared recipe files.`
@@ -12598,15 +13354,15 @@ async function installRecipe(target, options = {}) {
 }
 
 // src/pipeline/quality-regression.ts
-import path27 from "path";
-import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile21 } from "fs/promises";
-import { z as z9 } from "zod";
+import path29 from "path";
+import { existsSync as existsSync22 } from "fs";
+import { readFile as readFile24 } from "fs/promises";
+import { z as z10 } from "zod";
 var SHA256_RE2 = /^[0-9a-f]{64}$/;
 var HEX_RE = /^#[0-9a-f]{6}$/;
 var MAX_REDMEAN_DISTANCE = 765;
-var QualityPathSchema = z9.string().min(1).refine(
-  (value) => !path27.posix.isAbsolute(value) && !value.includes("\\"),
+var QualityPathSchema = z10.string().min(1).refine(
+  (value) => !path29.posix.isAbsolute(value) && !value.includes("\\"),
   "expected a portable relative path"
 );
 var DEFAULT_QUALITY_TOLERANCES = {
@@ -12619,53 +13375,53 @@ var DEFAULT_QUALITY_TOLERANCES = {
   maxEdgeContrastDrop: 0.03,
   maxIsolatedPixelIncrease: 5e-3
 };
-var QualityToleranceSchema = z9.object({
-  requireExactHash: z9.boolean(),
-  maxColorCountIncrease: z9.number().int().min(0),
-  maxNewColors: z9.number().int().min(0),
-  maxTransparencyDelta: z9.number().min(0).max(1),
-  maxPartialAlphaIncrease: z9.number().min(0).max(1),
-  maxEdgeDensityDelta: z9.number().min(0).max(1),
-  maxEdgeContrastDrop: z9.number().min(0).max(1),
-  maxIsolatedPixelIncrease: z9.number().min(0).max(1)
+var QualityToleranceSchema = z10.object({
+  requireExactHash: z10.boolean(),
+  maxColorCountIncrease: z10.number().int().min(0),
+  maxNewColors: z10.number().int().min(0),
+  maxTransparencyDelta: z10.number().min(0).max(1),
+  maxPartialAlphaIncrease: z10.number().min(0).max(1),
+  maxEdgeDensityDelta: z10.number().min(0).max(1),
+  maxEdgeContrastDrop: z10.number().min(0).max(1),
+  maxIsolatedPixelIncrease: z10.number().min(0).max(1)
 }).strict();
-var ImageQualityMetricsSchema = z9.object({
-  sha256: z9.string().regex(SHA256_RE2),
-  width: z9.number().int().min(1),
-  height: z9.number().int().min(1),
-  colorCount: z9.number().int().min(0),
-  colors: z9.array(z9.string().regex(HEX_RE)),
-  transparency: z9.number().min(0).max(1),
-  partialAlpha: z9.number().min(0).max(1),
-  edgeDensity: z9.number().min(0).max(1),
-  meanEdgeContrast: z9.number().min(0).max(1),
-  isolatedPixelRatio: z9.number().min(0).max(1)
+var ImageQualityMetricsSchema = z10.object({
+  sha256: z10.string().regex(SHA256_RE2),
+  width: z10.number().int().min(1),
+  height: z10.number().int().min(1),
+  colorCount: z10.number().int().min(0),
+  colors: z10.array(z10.string().regex(HEX_RE)),
+  transparency: z10.number().min(0).max(1),
+  partialAlpha: z10.number().min(0).max(1),
+  edgeDensity: z10.number().min(0).max(1),
+  meanEdgeContrast: z10.number().min(0).max(1),
+  isolatedPixelRatio: z10.number().min(0).max(1)
 }).strict();
-var QualityBaselineCaseSchema = z9.object({
-  id: z9.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+var QualityBaselineCaseSchema = z10.object({
+  id: z10.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
   file: QualityPathSchema,
-  record: z9.object({
+  record: z10.object({
     path: QualityPathSchema,
-    sha256: z9.string().regex(SHA256_RE2)
+    sha256: z10.string().regex(SHA256_RE2)
   }).strict().optional(),
   expected: ImageQualityMetricsSchema,
   tolerances: QualityToleranceSchema
 }).strict();
-var QualityBaselineSchema = z9.object({
-  $schema: z9.string().url().optional(),
-  format: z9.literal("pixelkiln-quality-baseline"),
-  schemaVersion: z9.literal(1),
-  cases: z9.array(QualityBaselineCaseSchema).min(1)
+var QualityBaselineSchema = z10.object({
+  $schema: z10.string().url().optional(),
+  format: z10.literal("pixelkiln-quality-baseline"),
+  schemaVersion: z10.literal(1),
+  cases: z10.array(QualityBaselineCaseSchema).min(1)
 }).strict().superRefine((baseline, context) => {
   const ids = baseline.cases.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) {
-    context.addIssue({ code: z9.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
+    context.addIssue({ code: z10.ZodIssueCode.custom, path: ["cases"], message: "duplicate case id" });
   }
 });
-var QualityInputSchema = z9.object({
-  id: z9.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
-  path: z9.string().min(1),
-  record: z9.string().min(1).optional(),
+var QualityInputSchema = z10.object({
+  id: z10.string().regex(/^[a-z0-9][a-z0-9/_-]*$/),
+  path: z10.string().min(1),
+  record: z10.string().min(1).optional(),
   tolerances: QualityToleranceSchema.partial().optional()
 }).strict();
 function message5(error) {
@@ -12753,10 +13509,10 @@ function measureDecodedImageQuality(png, digest2) {
   };
 }
 async function measureImageQuality(file) {
-  const absolute = path27.resolve(file);
+  const absolute = path29.resolve(file);
   let bytes;
   try {
-    bytes = await readFile21(absolute);
+    bytes = await readFile24(absolute);
   } catch (error) {
     throw new Error(`Cannot read quality image ${absolute}: ${message5(error)}`, { cause: error });
   }
@@ -12767,7 +13523,7 @@ async function measureImageQuality(file) {
   }
 }
 function resolveQualityInputs(raw, inputsFilePath) {
-  const parsed = z9.array(QualityInputSchema).min(1).safeParse(raw);
+  const parsed = z10.array(QualityInputSchema).min(1).safeParse(raw);
   if (!parsed.success) {
     throw new Error(
       "--inputs must be a non-empty JSON array of quality cases:\n" + parsed.error.issues.map((issue) => `  ${issue.path.join(".") || "$"}: ${issue.message}`).join("\n")
@@ -12775,11 +13531,11 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }
   const ids = parsed.data.map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) throw new Error("--inputs contains a duplicate quality case id.");
-  const root = path27.dirname(path27.resolve(inputsFilePath));
+  const root = path29.dirname(path29.resolve(inputsFilePath));
   return parsed.data.map((entry) => ({
     id: entry.id,
-    file: path27.resolve(root, entry.path),
-    ...entry.record ? { record: path27.resolve(root, entry.record) } : {},
+    file: path29.resolve(root, entry.path),
+    ...entry.record ? { record: path29.resolve(root, entry.record) } : {},
     tolerances: QualityToleranceSchema.parse({
       ...DEFAULT_QUALITY_TOLERANCES,
       ...entry.tolerances
@@ -12787,7 +13543,7 @@ function resolveQualityInputs(raw, inputsFilePath) {
   }));
 }
 function portableRelative2(from, to) {
-  return path27.relative(from, path27.resolve(to)).split(path27.sep).join("/") || ".";
+  return path29.relative(from, path29.resolve(to)).split(path29.sep).join("/") || ".";
 }
 async function verifyRecordForImage(recordPath, imagePath) {
   const verification = await verifyArtifactBundle(recordPath);
@@ -12802,20 +13558,20 @@ async function verifyRecordForImage(recordPath, imagePath) {
   if (record.kind !== "refine" || options === null || typeof options !== "object" || options.schema !== "pixelkiln-quality") {
     throw new Error(`Quality record ${recordPath} is not a PixelKiln refinement record.`);
   }
-  const outputs = record.outputs.map((output) => path27.resolve(path27.dirname(recordPath), output.path));
-  if (!outputs.includes(path27.resolve(imagePath))) {
+  const outputs = record.outputs.map((output) => path29.resolve(path29.dirname(recordPath), output.path));
+  if (!outputs.includes(path29.resolve(imagePath))) {
     throw new Error(`Quality record ${recordPath} does not own ${imagePath}.`);
   }
 }
 async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   if (!inputs.length) throw new Error("Cannot snapshot an empty quality baseline.");
-  const absolute = path27.resolve(baselinePath);
+  const absolute = path29.resolve(baselinePath);
   for (const input of inputs) {
-    if (path27.resolve(input.file) === absolute || input.record && path27.resolve(input.record) === absolute) {
+    if (path29.resolve(input.file) === absolute || input.record && path29.resolve(input.record) === absolute) {
       throw new Error(`Quality baseline output would overwrite an input: ${absolute}.`);
     }
   }
-  const root = path27.dirname(absolute);
+  const root = path29.dirname(absolute);
   const cases = [];
   for (const input of [...inputs].sort((a, b) => a.id.localeCompare(b.id))) {
     const expected = await measureImageQuality(input.file);
@@ -12842,8 +13598,8 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
     cases
   });
   const data = Buffer.from(JSON.stringify(baseline, null, 2) + "\n");
-  if (existsSync21(absolute) && !options.force) {
-    const current = await readFile21(absolute);
+  if (existsSync22(absolute) && !options.force) {
+    const current = await readFile24(absolute);
     if (!current.equals(data)) {
       throw new Error(`Quality baseline already exists with different content: ${absolute}. Pass --force to replace it.`);
     }
@@ -12852,10 +13608,10 @@ async function snapshotQualityBaseline(inputs, baselinePath, options = {}) {
   return { baseline, path: absolute, changed: result.changed.length > 0 };
 }
 async function readQualityBaseline(baselinePath) {
-  const absolute = path27.resolve(baselinePath);
+  const absolute = path29.resolve(baselinePath);
   let raw;
   try {
-    raw = JSON.parse(await readFile21(absolute, "utf8"));
+    raw = JSON.parse(await readFile24(absolute, "utf8"));
   } catch (error) {
     throw new Error(`Could not read quality baseline ${absolute}: ${message5(error)}`, { cause: error });
   }
@@ -12925,12 +13681,12 @@ function regressionViolations(expected, actual, tolerances) {
   return { violations, warnings };
 }
 async function checkQualityBaseline(baselinePath) {
-  const absolute = path27.resolve(baselinePath);
+  const absolute = path29.resolve(baselinePath);
   const baseline = await readQualityBaseline(absolute);
-  const root = path27.dirname(absolute);
+  const root = path29.dirname(absolute);
   const cases = [];
   for (const entry of baseline.cases) {
-    const file = path27.resolve(root, entry.file);
+    const file = path29.resolve(root, entry.file);
     let actual = null;
     const violations = [];
     const warnings = [];
@@ -12943,7 +13699,7 @@ async function checkQualityBaseline(baselinePath) {
       violations.push(message5(error));
     }
     if (entry.record) {
-      const recordPath = path27.resolve(root, entry.record.path);
+      const recordPath = path29.resolve(root, entry.record.path);
       try {
         const recordHash = await sha256File(recordPath);
         if (recordHash !== entry.record.sha256) violations.push("quality record hash changed");
@@ -13029,13 +13785,13 @@ async function runGallery(initial, reload, args, access2) {
   };
   const loadProject = async (project) => {
     const ctx = await access2.loadProject(project);
-    const dir = path28.dirname(ctx.loaded.path);
+    const dir = path30.dirname(ctx.loaded.path);
     const declared = readEnvFiles(dir);
     const credentialNames = new Set(availableProviders().flatMap((id) => providerCredentialEnvs(providerFactory(id))));
     for (const [name, value] of Object.entries(declared)) {
       if (credentialNames.has(name) && name in process.env && process.env[name] !== value) {
         throw new Error(
-          `${path28.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
+          `${path30.relative(process.cwd(), dir) || "."} sets ${name} to a different value than the one this gallery already loaded; run a separate gallery for that project so its work uses its own account.`
         );
       }
     }
@@ -13062,7 +13818,9 @@ async function runGallery(initial, reload, args, access2) {
       budget ? describeBudget(budget) : null
     ),
     ...args.edit ? { edit: createGalleryEditHandler({ manifestFor: access2.manifestFor, loadProject: access2.loadProject, reload, onProgress: log }) } : {},
-    ...budget ? { generate: createGenerateHandlers({ loadProject, providerFor, budget, reload, onProgress: log }) } : {}
+    ...budget ? { generate: createGenerateHandlers({ loadProject, providerFor, budget, reload, onProgress: log }) } : {},
+    // The editor exists to write hand edits back, so it follows the write gate.
+    ...args.edit && !args.noEditor ? { editor: createGalleryEditorHandlers({ onProgress: log }) } : {}
   });
   await new Promise((resolve) => {
     const stop = () => {
@@ -13077,11 +13835,11 @@ async function runGallery(initial, reload, args, access2) {
   log("\n  gallery closed");
 }
 async function provenanceFile(id, file) {
-  const absolute = path28.resolve(file);
+  const absolute = path30.resolve(file);
   return {
     id,
     path: absolute,
-    sha256: existsSync22(absolute) ? await sha256File(absolute) : null,
+    sha256: existsSync23(absolute) ? await sha256File(absolute) : null,
     included: true
   };
 }
@@ -13131,7 +13889,8 @@ var BOOL_FLAGS = [
   "--primary-only",
   "--prune",
   "--edit",
-  "--refresh"
+  "--refresh",
+  "--no-editor"
 ];
 var COMMANDS = [
   "init",
@@ -13158,6 +13917,7 @@ var COMMANDS = [
   "status",
   "gallery",
   "edit",
+  "tools",
   "quality",
   "refine",
   "recipe",
@@ -13173,6 +13933,8 @@ var REFINE_SUBCOMMANDS = ["run", "approve", "check"];
 var RECIPE_SUBCOMMANDS = ["list", "inspect", "install", "verify"];
 var QUALITY_SUBCOMMANDS = ["snapshot", "check"];
 var EDIT_SUBCOMMANDS = ["start", "detach"];
+var TOOLS_SUBCOMMANDS = ["status", "install"];
+var TOOLS = ["editor"];
 function parseArgs(argv) {
   const [command = "help"] = argv;
   if (!COMMANDS.includes(command)) {
@@ -13236,6 +13998,22 @@ function parseArgs(argv) {
       throw new Error(`Unknown edit subcommand "${subcommand}". Known: ${EDIT_SUBCOMMANDS.join(", ")}`);
     }
     if (rest[0] === subcommand) rest = rest.slice(1);
+  } else if (command === "tools") {
+    subcommand = rest[0]?.startsWith("-") || rest[0] === void 0 ? "status" : rest[0];
+    if (!TOOLS_SUBCOMMANDS.includes(subcommand)) {
+      throw new Error(`Unknown tools subcommand "${subcommand}". Known: ${TOOLS_SUBCOMMANDS.join(", ")}`);
+    }
+    if (rest[0] === subcommand) rest = rest.slice(1);
+    target = rest[0]?.startsWith("-") ? void 0 : rest[0];
+    if (subcommand === "install" && target === void 0) {
+      throw new Error(`tools install needs a tool name: ${TOOLS.join(", ")}`);
+    }
+    if (target !== void 0) {
+      if (!TOOLS.includes(target)) {
+        throw new Error(`Unknown tool "${target}". Known: ${TOOLS.join(", ")}`);
+      }
+      rest = rest.slice(1);
+    }
   } else if (command === "refine") {
     subcommand = rest[0]?.startsWith("-") || rest[0] === void 0 ? "run" : rest[0];
     if (!REFINE_SUBCOMMANDS.includes(subcommand)) {
@@ -13349,7 +14127,7 @@ function parseArgs(argv) {
   return {
     command,
     manifest,
-    lock: get("--lock") ?? path28.join(path28.dirname(path28.resolve(manifest)), "pixelkiln.lock.json"),
+    lock: get("--lock") ?? path30.join(path30.dirname(path30.resolve(manifest)), "pixelkiln.lock.json"),
     explicitLock: get("--lock"),
     styles: list("--style"),
     assets: list("--only"),
@@ -13364,6 +14142,7 @@ function parseArgs(argv) {
     noOpen: rest.includes("--no-open"),
     tag: rest.includes("--tag"),
     edit: rest.includes("--edit"),
+    noEditor: rest.includes("--no-editor"),
     refresh: rest.includes("--refresh"),
     from: get("--from"),
     out: get("--out"),
@@ -13397,6 +14176,45 @@ function parseArgs(argv) {
     account: get("--account")
   };
 }
+async function runTools(args) {
+  const mb = (bytes) => bytes < 1e6 ? `${(bytes / 1e3).toFixed(0)} kB` : `${(bytes / 1e6).toFixed(1)} MB`;
+  if (args.subcommand === "status") {
+    const status2 = await editorStatus();
+    if (args.json) {
+      log(JSON.stringify({ version: 1, editor: { ...status2, pixelorama: EDITOR_PIN.pixelorama, protocol: EDITOR_PIN.protocol } }, null, 2));
+      return;
+    }
+    log(`  editor  Pixelorama ${EDITOR_PIN.pixelorama} (bridge protocol ${EDITOR_PIN.protocol})`);
+    if (!status2.release) {
+      log("          no published build is pinned by this PixelKiln version");
+      return;
+    }
+    log(`          release ${status2.release}`);
+    log(`          ${status2.installed ? "installed and verified" : status2.installedBytes ? `partial: ${status2.missing.length} of ${Object.keys(EDITOR_PIN.files).length} files missing` : "not installed"} \u2014 ${mb(status2.totalBytes)} in ${status2.dir}`);
+    if (!status2.installed) log("          run: pixelkiln tools install editor");
+    return;
+  }
+  const status = await editorStatus();
+  if (status.installed) {
+    log(`  editor is already installed and verified in ${status.dir}`);
+    return;
+  }
+  if (!status.release) {
+    throw new Error("this PixelKiln version pins no published editor build; upgrade, or set PIXELKILN_EDITOR_URL to a build you trust");
+  }
+  log(`  fetching ${status.missing.length} file(s), ${mb(status.totalBytes - status.installedBytes)}, from release ${status.release}`);
+  try {
+    const result = await installEditor({
+      onProgress: (p) => {
+        if (p.phase === "start") log(`    ${p.file.padEnd(34)} ${mb(p.bytes).padStart(9)}`);
+      }
+    });
+    log(`  editor ready in ${result.dir} (${result.downloaded.length} fetched, ${result.skipped.length} already present, every hash verified)`);
+  } catch (err) {
+    if (err instanceof EditorInstallError) throw new Error(`editor install failed: ${err.message}`);
+    throw err;
+  }
+}
 var HELP = `pixelkiln \u2014 manifest-driven pixel art generation
 
   pixelkiln <command> [options]
@@ -13437,8 +14255,12 @@ Commands
   gallery   Open a local read-only gallery of every generation and its
             provenance: prompt, provider, cost, outputs, lineage, quality.
             --workspace <catalog> shows every registered project at once;
-            --edit lets the page change prompts, sizes, tags, and add assets;
+            --edit lets the page change prompts, sizes, tags, and add assets,
+            and offers the in-browser pixel editor (--no-editor hides it);
             --budget enables Generate, Regenerate, and review under that ceiling.
+  tools     status/install editor: the in-browser editor (Pixelorama) is a
+            46 MB web build fetched once per release into a user cache and
+            verified against pinned hashes. Offline once installed.
   workspace Register sibling projects and derive account-wide claims/status.
             add/remove/list/status/claims. Offline.
 
@@ -13478,6 +14300,7 @@ Options
   --yes, -y           Skip the confirmation prompt
   --no-open           Do not auto-open the browser (pick, salvage, gallery) or editor (edit)
   --edit              gallery: allow manifest edits from the page (never spends)
+  --no-editor         gallery: do not offer or serve the in-browser editor
   --tag               Also push tags upstream after fetch
   --refresh           fetch: re-download and replace files whose object changed
                       upstream (e.g. edited in PixelLab's editor); no generation
@@ -13496,6 +14319,7 @@ Examples
   pixelkiln gallery --workspace pixelkiln.workspace.json
   pixelkiln gallery --edit --budget 80
   pixelkiln edit --style base --only anvil
+  pixelkiln tools install editor
   PIXELKILN_EDITOR="open -a Aseprite" pixelkiln edit --only anvil --style base
   pixelkiln adopt --tag
   pixelkiln pack --style heybud-premium
@@ -13655,10 +14479,10 @@ async function confirm(question, auto) {
   return answer === "y" || answer === "yes";
 }
 async function requireCompleteWorkspaceClaims(workspacePath) {
-  if (!existsSync22(workspacePath)) {
+  if (!existsSync23(workspacePath)) {
     throw new Error(`Workspace catalog not found: ${workspacePath}`);
   }
-  const dir = path28.dirname(path28.resolve(workspacePath));
+  const dir = path30.dirname(path30.resolve(workspacePath));
   const ws = await loadWorkspace(workspacePath);
   const diagnostics = validateWorkspace(ws, dir);
   const errors = diagnostics.filter((d) => d.level === "error");
@@ -13679,26 +14503,30 @@ async function main() {
   }
   if (args.command === "--version" || args.command === "-v") {
     const pkg = JSON.parse(
-      await readFile22(new URL("../package.json", import.meta.url), "utf8")
+      await readFile25(new URL("../package.json", import.meta.url), "utf8")
     );
     log(`${pkg.name} ${pkg.version}`);
     return;
   }
+  if (args.command === "tools") {
+    await runTools(args);
+    return;
+  }
   if (args.command === "quality") {
     if (args.subcommand === "snapshot") {
       if (!args.inputs) throw new Error("quality snapshot needs --inputs <quality-inputs.json>.");
       if (!args.out) throw new Error("quality snapshot needs --out <pixelkiln.quality.json>.");
       let raw;
       try {
-        raw = JSON.parse(await readFile22(path28.resolve(args.inputs), "utf8"));
+        raw = JSON.parse(await readFile25(path30.resolve(args.inputs), "utf8"));
       } catch (error) {
         throw new Error(
-          `Could not read quality inputs ${path28.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
+          `Could not read quality inputs ${path30.resolve(args.inputs)}: ${error instanceof Error ? error.message : String(error)}`,
           { cause: error }
         );
       }
       const inputs = resolveQualityInputs(raw, args.inputs);
-      if (path28.resolve(args.inputs) === path28.resolve(args.out)) {
+      if (path30.resolve(args.inputs) === path30.resolve(args.out)) {
         throw new Error("quality snapshot --out must not overwrite its --inputs file.");
       }
       const result = await snapshotQualityBaseline(inputs, args.out, { force: args.force });
@@ -13711,7 +14539,7 @@ async function main() {
         }, null, 2));
       } else {
         log(
-          `  ${result.changed ? "wrote" : "unchanged"} ${path28.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
+          `  ${result.changed ? "wrote" : "unchanged"} ${path30.relative(process.cwd(), result.path)} (${result.baseline.cases.length} case(s))`
         );
         log(`  Review the tolerances, commit the baseline, then run quality check in CI.`);
       }
@@ -13806,14 +14634,14 @@ async function main() {
         }, null, 2));
       } else {
         log(`  installed ${result.recipe.id}@${result.recipe.version}`);
-        log(`  ${path28.relative(process.cwd(), result.destination) || "."}`);
+        log(`  ${path30.relative(process.cwd(), result.destination) || "."}`);
         log(`
   Add this entry under your manifest's styles object:`);
         log(JSON.stringify({ [result.styleId]: result.style }, null, 2));
         if (result.recipe.models.length) {
           log(`
   Models are not downloaded automatically. Verify them with:`);
-          log(`  pixelkiln recipe verify ${path28.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
+          log(`  pixelkiln recipe verify ${path30.relative(process.cwd(), result.destination)} --model-root <ComfyUI/models>`);
         }
       }
       return;
@@ -13847,12 +14675,12 @@ async function main() {
           `  recovered ${result2.detection.columns}x${result2.detection.rows} native grid (${result2.detection.confidence}: ${result2.detection.consensus})`
         );
         log(`  enforced ${result2.palette.length}-color palette without dithering`);
-        log(`  wrote ${path28.relative(process.cwd(), result2.output)}`);
-        log(`  quality record: ${path28.relative(process.cwd(), result2.record)}`);
+        log(`  wrote ${path30.relative(process.cwd(), result2.output)}`);
+        log(`  quality record: ${path30.relative(process.cwd(), result2.record)}`);
         log(`
   Automated checks passed. Human 1\xD7 review is still required:`);
         log(
-          `    pixelkiln refine approve --from ${path28.relative(process.cwd(), result2.record)} --reviewer "Your Name"`
+          `    pixelkiln refine approve --from ${path30.relative(process.cwd(), result2.record)} --reviewer "Your Name"`
         );
       }
       return;
@@ -13880,7 +14708,7 @@ async function main() {
       if (args.json) log(JSON.stringify(result2, null, 2));
       else {
         log(
-          result2.options.frameSet ? `  approved ${result2.outputs.length} frames in ${path28.relative(process.cwd(), result2.record)} by ${args.reviewer.trim()}` : `  approved ${path28.relative(process.cwd(), result2.output)} by ${args.reviewer.trim()}`
+          result2.options.frameSet ? `  approved ${result2.outputs.length} frames in ${path30.relative(process.cwd(), result2.record)} by ${args.reviewer.trim()}` : `  approved ${path30.relative(process.cwd(), result2.output)} by ${args.reviewer.trim()}`
         );
       }
       return;
@@ -13889,14 +14717,14 @@ async function main() {
     if (args.json) {
       log(JSON.stringify(result, null, 2));
     } else {
-      log(`  ${result.safe ? "release-ready" : "not release-ready"}: ${path28.relative(process.cwd(), result.output || result.record)}`);
+      log(`  ${result.safe ? "release-ready" : "not release-ready"}: ${path30.relative(process.cwd(), result.output || result.record)}`);
       for (const reason of result.reasons) log(`    ${reason}`);
     }
     if (!result.safe) process.exitCode = 1;
     return;
   }
   if (args.command === "balance") {
-    loadEnvFiles(path28.dirname(path28.resolve(args.manifest)));
+    loadEnvFiles(path30.dirname(path30.resolve(args.manifest)));
     loadEnvFiles(process.cwd());
     const loaded2 = await loadManifest(args.manifest);
     const selectedProvider = accountProviderId(loaded2.manifest, args.provider, "balance");
@@ -13909,31 +14737,31 @@ async function main() {
   }
   if (args.command === "init") {
     if (!args.from) throw new Error("init needs --from <dir> pointing at your existing PNGs.");
-    const root = path28.resolve(args.from);
-    if (!existsSync22(root)) throw new Error(`No directory at ${root}`);
+    const root = path30.resolve(args.from);
+    if (!existsSync23(root)) throw new Error(`No directory at ${root}`);
     const generator = args.generator ?? "map";
     if (generator !== "1dir" && generator !== "map") {
       throw new Error(`--generator must be "1dir" or "map", got "${args.generator}".`);
     }
-    const target = path28.resolve(args.out ?? "pixelkiln.manifest.json");
+    const target = path30.resolve(args.out ?? "pixelkiln.manifest.json");
     const { assets, skipped } = await scanAssets(root, { exclude: args.exclude });
     if (!assets.length) throw new Error(`No PNGs found under ${root}`);
     const manifest = buildManifest(
-      args.name ?? path28.basename(path28.dirname(target)),
+      args.name ?? path30.basename(path30.dirname(target)),
       args.styles[0] ?? "base",
       generator,
-      path28.relative(path28.dirname(target), root) || ".",
+      path30.relative(path30.dirname(target), root) || ".",
       assets
     );
     await writeManifestFile(target, manifest);
-    log(`  scanned ${assets.length} PNG(s) under ${path28.relative(process.cwd(), root)}`);
+    log(`  scanned ${assets.length} PNG(s) under ${path30.relative(process.cwd(), root)}`);
     if (skipped.length) log(`  skipped ${skipped.length} unreadable file(s)`);
-    log(`  wrote ${path28.relative(process.cwd(), target)}`);
+    log(`  wrote ${path30.relative(process.cwd(), target)}`);
     log(`
   Prompts are intentionally empty. To recover the real ones from your`);
     log(`  PixelLab account instead of inventing them:`);
     log(`
-    pixelkiln adopt --manifest ${path28.relative(process.cwd(), target)} --write-prompts
+    pixelkiln adopt --manifest ${path30.relative(process.cwd(), target)} --write-prompts
 `);
     return;
   }
@@ -13981,10 +14809,10 @@ async function main() {
     if (args.primaryOnly || args.outputRoles.length) {
       throw new Error("--primary-only and --output-role require manifest-driven pack");
     }
-    const raw = JSON.parse(await readFile22(path28.resolve(args.inputs), "utf8"));
+    const raw = JSON.parse(await readFile25(path30.resolve(args.inputs), "utf8"));
     const inputs = resolvePackInputs(raw, args.inputs);
     const { png, atlas, skipped, sources } = packSprites(inputs, { columns: args.columns });
-    const base = path28.resolve(args.out.replace(/\.png$/, ""));
+    const base = path30.resolve(args.out.replace(/\.png$/, ""));
     const outputs = [
       { path: `${base}.png`, data: png },
       { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -13997,17 +14825,17 @@ async function main() {
     log(
       `  ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s) \u2014 ${(png.length / 1024).toFixed(1)} KB`
     );
-    log(`    ${path28.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+    log(`    ${path30.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
     for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     return;
   }
   if (args.command === "workspace") {
-    const workspacePath = path28.resolve(args.workspace ?? "pixelkiln.workspace.json");
-    const dir = path28.dirname(workspacePath);
+    const workspacePath = path30.resolve(args.workspace ?? "pixelkiln.workspace.json");
+    const dir = path30.dirname(workspacePath);
     if (args.subcommand === "add") {
-      const manifestPath = path28.resolve(args.target);
+      const manifestPath = path30.resolve(args.target);
       const loadedTarget = await loadManifest(manifestPath);
-      const lockPath = args.explicitLock ? path28.resolve(args.explicitLock) : path28.join(path28.dirname(manifestPath), "pixelkiln.lock.json");
+      const lockPath = args.explicitLock ? path30.resolve(args.explicitLock) : path30.join(path30.dirname(manifestPath), "pixelkiln.lock.json");
       const ws = await loadWorkspace(workspacePath);
       const id = args.name ?? loadedTarget.manifest.name;
       if (ws.projects.some((p) => p.id === id)) {
@@ -14027,10 +14855,10 @@ async function main() {
         ...args.account ? { account: args.account } : {}
       };
       await saveWorkspace(workspacePath, { version: 1, projects: [...ws.projects, project] });
-      log(`  registered "${id}" in ${path28.relative(process.cwd(), workspacePath)}`);
+      log(`  registered "${id}" in ${path30.relative(process.cwd(), workspacePath)}`);
       log(`    manifest: ${project.manifest}`);
       log(`    lock:     ${project.lock}`);
-      if (!existsSync22(lockPath)) {
+      if (!existsSync23(lockPath)) {
         log(
           `  warning: no lockfile there yet \u2014 this project contributes no claims until one is generated`
         );
@@ -14039,7 +14867,7 @@ async function main() {
     }
     if (args.subcommand === "remove") {
       const ws = await loadWorkspace(workspacePath);
-      const resolvedTarget = path28.resolve(args.target);
+      const resolvedTarget = path30.resolve(args.target);
       const match = ws.projects.find(
         (p) => p.id === args.target || resolveProject(dir, p).manifestPath === resolvedTarget
       );
@@ -14050,11 +14878,11 @@ async function main() {
         version: 1,
         projects: ws.projects.filter((p) => p !== match)
       });
-      log(`  removed "${match.id}" from ${path28.relative(process.cwd(), workspacePath)}`);
+      log(`  removed "${match.id}" from ${path30.relative(process.cwd(), workspacePath)}`);
       return;
     }
     if (args.subcommand === "list") {
-      if (!existsSync22(workspacePath)) {
+      if (!existsSync23(workspacePath)) {
         throw new Error(`Workspace catalog not found: ${workspacePath}`);
       }
       const ws = await loadWorkspace(workspacePath);
@@ -14062,9 +14890,9 @@ async function main() {
       if (args.json) {
         log(JSON.stringify({ version: 1, workspace: workspacePath, projects: ws.projects, diagnostics }, null, 2));
       } else if (!ws.projects.length) {
-        log(`  no projects registered in ${path28.relative(process.cwd(), workspacePath)}`);
+        log(`  no projects registered in ${path30.relative(process.cwd(), workspacePath)}`);
       } else {
-        log(`  ${ws.projects.length} project(s) in ${path28.relative(process.cwd(), workspacePath)}:`);
+        log(`  ${ws.projects.length} project(s) in ${path30.relative(process.cwd(), workspacePath)}:`);
         for (const p of ws.projects) {
           log(`    ${p.id.padEnd(24)} ${p.manifest.padEnd(40)} (${p.provider}${p.account ? `, ${p.account}` : ""})`);
         }
@@ -14074,7 +14902,7 @@ async function main() {
       return;
     }
     if (args.subcommand === "status") {
-      if (!existsSync22(workspacePath)) {
+      if (!existsSync23(workspacePath)) {
         throw new Error(`Workspace catalog not found: ${workspacePath}`);
       }
       const ws = await loadWorkspace(workspacePath);
@@ -14082,7 +14910,7 @@ async function main() {
       if (args.json) {
         log(JSON.stringify({ ...report, workspace: workspacePath }, null, 2));
       } else {
-        log(`  workspace: ${path28.relative(process.cwd(), workspacePath)}`);
+        log(`  workspace: ${path30.relative(process.cwd(), workspacePath)}`);
         for (const p of report.projects) {
           if (p.error) {
             log(`
@@ -14129,8 +14957,8 @@ async function main() {
     }
   }
   if (args.command === "gallery" && args.workspace) {
-    const workspacePath = path28.resolve(args.workspace);
-    if (!existsSync22(workspacePath)) {
+    const workspacePath = path30.resolve(args.workspace);
+    if (!existsSync23(workspacePath)) {
       throw new Error(`Workspace catalog not found: ${workspacePath}`);
     }
     const filter = { styles: args.styles, assets: args.assets };
@@ -14150,7 +14978,7 @@ async function main() {
     const registered = async (projectId) => {
       const project = (await loadWorkspace(workspacePath)).projects.find((candidate) => candidate.id === projectId);
       if (!projectId || !project) throw new Error(`unknown workspace project "${projectId ?? ""}"`);
-      return resolveProject(path28.dirname(workspacePath), project);
+      return resolveProject(path30.dirname(workspacePath), project);
     };
     await runGallery(initial, build, args, {
       manifestFor: async (projectId) => (await registered(projectId)).manifestPath,
@@ -14165,14 +14993,14 @@ async function main() {
     });
     return;
   }
-  if (!existsSync22(path28.resolve(args.manifest))) {
+  if (!existsSync23(path30.resolve(args.manifest))) {
     throw new Error(
-      `No manifest at ${path28.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
+      `No manifest at ${path30.resolve(args.manifest)}. Pass --manifest, or run \`pixelkiln init --from <dir>\`.`
     );
   }
-  const manifestDir = path28.dirname(path28.resolve(args.manifest));
+  const manifestDir = path30.dirname(path30.resolve(args.manifest));
   const envFiles2 = [...loadEnvFiles(manifestDir)];
-  if (path28.resolve(process.cwd()) !== manifestDir) envFiles2.push(...loadEnvFiles(process.cwd()));
+  if (path30.resolve(process.cwd()) !== manifestDir) envFiles2.push(...loadEnvFiles(process.cwd()));
   const loaded = await loadManifest(args.manifest);
   let specs = await resolveSpecs(loaded, {
     styles: args.styles,
@@ -14245,7 +15073,7 @@ async function main() {
       });
     };
     await runGallery(await build(), reload, args, {
-      manifestFor: () => path28.resolve(args.manifest),
+      manifestFor: () => path30.resolve(args.manifest),
       loadProject: async () => {
         const freshLoaded = await loadManifest(args.manifest);
         const freshSpecs = await resolveSpecs(freshLoaded);
@@ -14320,7 +15148,7 @@ async function main() {
         log(`  ${item.state.padEnd(16)} ${item.key}  ${item.reason}`);
         if (item.state === "needs-approval") {
           log(
-            `    pixelkiln refine approve --from ${path28.relative(process.cwd(), item.record)} --reviewer "Your Name"`
+            `    pixelkiln refine approve --from ${path30.relative(process.cwd(), item.record)} --reviewer "Your Name"`
           );
         }
       }
@@ -14411,7 +15239,7 @@ async function main() {
       let intact = true;
       for (const output of entry.outputs) {
         const file = resolveOutputPath(output.path, item.spec.root);
-        if (!existsSync22(file) || await sha256File(file) !== output.sha256) {
+        if (!existsSync23(file) || await sha256File(file) !== output.sha256) {
           intact = false;
           break;
         }
@@ -14469,7 +15297,7 @@ async function main() {
     if (args.primaryOnly && args.outputRoles.length) {
       throw new Error("pack accepts either --primary-only or --output-role, not both");
     }
-    const manifestDir2 = path28.dirname(path28.resolve(args.manifest));
+    const manifestDir2 = path30.dirname(path30.resolve(args.manifest));
     const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
     for (const styleId of styleIds) {
       const packagingSpecs = await resolveSpecs(loaded, { styles: [styleId] });
@@ -14482,7 +15310,7 @@ async function main() {
         sources: manifestSources(loaded.manifest, styleId)
       });
       const style = loaded.manifest.styles[styleId];
-      const base = args.out ? path28.resolve(args.out.replace(/\.png$/, "")) : path28.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
+      const base = args.out ? path30.resolve(args.out.replace(/\.png$/, "")) : path30.resolve(manifestDir2, style.outDir, `${styleId}-sheet`);
       const outputs = [
         { path: `${base}.png`, data: png },
         { path: `${base}.json`, data: JSON.stringify(atlas, null, 2) + "\n" }
@@ -14512,13 +15340,13 @@ async function main() {
       log(
         `  ${styleId} \u2014 ${atlas.frames.length} sprite(s), ${atlas.sheet.width}x${atlas.sheet.height} in ${atlas.columns} column(s)`
       );
-      log(`    ${path28.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
+      log(`    ${path30.relative(process.cwd(), base)}.png + .json + .pixelkiln.json`);
       for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     }
     return;
   }
   if (args.command === "mount") {
-    const manifestDir2 = path28.dirname(path28.resolve(args.manifest));
+    const manifestDir2 = path30.dirname(path30.resolve(args.manifest));
     const styleIds = args.styles.length ? args.styles : Object.keys(loaded.manifest.styles);
     for (const styleId of styleIds) {
       const style = loaded.manifest.styles[styleId];
@@ -14557,7 +15385,7 @@ async function main() {
         sources,
         outputRoles
       );
-      const out = path28.resolve(manifestDir2, style.mount.out);
+      const out = path30.resolve(manifestDir2, style.mount.out);
       const metadata = out.replace(/\.png$/, "") + ".json";
       const companion = out.replace(/\.png$/, "") + ".pixelkiln.json";
       const outputs = [
@@ -14577,7 +15405,7 @@ async function main() {
           await provenanceFile("$lock", args.lock),
           ...qualityRecords,
           ...artifactSources.filter(
-            (source) => source.id !== "$base" || path28.resolve(source.path) !== out
+            (source) => source.id !== "$base" || path30.resolve(source.path) !== out
           )
         ],
         options: {
@@ -14590,7 +15418,7 @@ async function main() {
       log(
         `  ${styleId} \u2014 ${atlas.frames.length} cell(s) into ${atlas.sheet.width}x${atlas.sheet.height}` + (overBase ? ` over ${style.mount.base}` : " (new sheet)")
       );
-      log(`    ${path28.relative(process.cwd(), out)} + atlas/provenance JSON`);
+      log(`    ${path30.relative(process.cwd(), out)} + atlas/provenance JSON`);
       for (const s of skipped) log(`    skipped ${s.id}: ${s.reason}`);
     }
     return;
@@ -14646,7 +15474,7 @@ async function main() {
   }
   if (args.command === "export") {
     const format = args.format ?? "generic";
-    const manifestDir2 = path28.dirname(path28.resolve(args.manifest));
+    const manifestDir2 = path30.dirname(path30.resolve(args.manifest));
     const selected = specs.filter((spec) => {
       if (spec.generator !== "tiles") return false;
       if (args.styles.length && !args.styles.includes(spec.styleId)) return false;
@@ -14662,12 +15490,12 @@ async function main() {
     for (const spec of selected) {
       const entry = lock.entries[lockKey(spec.styleId, spec.assetId)];
       const style = loaded.manifest.styles[spec.styleId];
-      const defaultBase = path28.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
-      const base = args.out ? path28.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
+      const defaultBase = path30.resolve(manifestDir2, style.outDir, `${spec.assetId}-tileset`);
+      const base = args.out ? path30.resolve(args.out.replace(/\.(?:png|json|tsj|tres)$/i, "")) : defaultBase;
       const result = exportTileset(entry, spec, {
         format,
         manifestDir: manifestDir2,
-        imageName: path28.basename(`${base}.png`),
+        imageName: path30.basename(`${base}.png`),
         columns: args.columns
       });
       const outputs = [
@@ -14685,7 +15513,7 @@ async function main() {
           asset: spec.assetId,
           columns: args.columns ?? null,
           format,
-          image: path28.basename(`${base}.png`),
+          image: path30.basename(`${base}.png`),
           providerRules: result.generic.providerRules,
           style: spec.styleId,
           tileType: spec.tileType ?? null
@@ -14695,7 +15523,7 @@ async function main() {
         `  ${spec.styleId}/${spec.assetId} \u2014 ${result.generic.tiles.length} tile(s), ${result.generic.sheet.width}x${result.generic.sheet.height} (${format})`
       );
       log(
-        `    ${path28.relative(process.cwd(), base)}.png + ${path28.basename(base)}${result.extension} + .pixelkiln.json`
+        `    ${path30.relative(process.cwd(), base)}.png + ${path30.basename(base)}${result.extension} + .pixelkiln.json`
       );
     }
     return;
@@ -14745,12 +15573,12 @@ async function main() {
   tagged ${n} object(s) upstream`);
     }
     if (args.writePrompts) {
-      const { filled, stillEmpty } = await writePromptsBack(path28.resolve(args.manifest), lock, {
+      const { filled, stillEmpty } = await writePromptsBack(path30.resolve(args.manifest), lock, {
         onProgress: log,
         provider: provider.id,
         assetIds: specs.map((spec) => spec.assetId)
       });
-      log(`  recovered ${filled} prompt(s) into ${path28.relative(process.cwd(), args.manifest)}`);
+      log(`  recovered ${filled} prompt(s) into ${path30.relative(process.cwd(), args.manifest)}`);
       const reloaded = await loadManifest(args.manifest);
       const rebased = (await resolveSpecs(reloaded, {
         styles: args.styles,
@@ -14779,12 +15607,12 @@ async function main() {
     const provider = providerFor(selectedAccountProvider);
     const jsonMode = args.dryRun && args.json;
     const diag = jsonMode ? (msg = "") => console.error(msg) : log;
-    const ownLock = path28.resolve(args.lock);
+    const ownLock = path30.resolve(args.lock);
     let workspaceProjects = [];
     let workspaceDir = "";
     if (args.workspace) {
-      const workspacePath = path28.resolve(args.workspace);
-      workspaceDir = path28.dirname(workspacePath);
+      const workspacePath = path30.resolve(args.workspace);
+      workspaceDir = path30.dirname(workspacePath);
       const complete = await requireCompleteWorkspaceClaims(workspacePath);
       workspaceProjects = complete.ws.projects;
       for (const d of complete.diagnostics) diag(`  WARN  ${d.id}: ${d.message}`);
@@ -14793,12 +15621,12 @@ async function main() {
     const lockPaths = [
       .../* @__PURE__ */ new Set([
         ...workspaceLockPaths,
-        ...existsSync22(ownLock) ? [ownLock] : [],
-        ...args.claims.map((c) => path28.resolve(c))
+        ...existsSync23(ownLock) ? [ownLock] : [],
+        ...args.claims.map((c) => path30.resolve(c))
       ])
     ];
     diag(`  claim set (${lockPaths.length} lockfile(s)):`);
-    for (const p of lockPaths) diag(`    ${path28.relative(process.cwd(), p)}`);
+    for (const p of lockPaths) diag(`    ${path30.relative(process.cwd(), p)}`);
     if (!args.claims.length && !args.workspace) {
       diag(
         `
@@ -14806,7 +15634,7 @@ async function main() {
   pass every other project's lockfile via --claims a.json,b.json, or
   register every project in a workspace catalog and pass --workspace.`
       );
-    } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path28.resolve(args.manifest))) {
+    } else if (args.workspace && !workspaceProjects.some((p) => resolveProject(workspaceDir, p).manifestPath === path30.resolve(args.manifest))) {
       diag(
         `
   This project's manifest is not registered in the workspace catalog. Its own
@@ -14890,7 +15718,7 @@ async function main() {
           manifestPath: loaded.path,
           manifest: accountManifest,
           styleId,
-          importDir: path28.resolve(loaded.root, style.outDir),
+          importDir: path30.resolve(loaded.root, style.outDir),
           lock,
           lockPath: args.lock
         },