pixelkiln 0.52.0 → 0.53.1

package/dist/client/gallery.js

@@ -111,6 +111,20 @@ const paletteRuleOf = (item) => {
   const style = snap.styles.find((s) => s.id === item.styleId && s.project === item.project);
   return style && style.enforcePalette && style.palette.length >= 2 ? style.palette : null;
 };
+/**
+ * Whether this item has usable pixels to revise: committed `source` art
+ * always qualifies, otherwise it needs a current, downloaded generation, or
+ * (for a quality-gated style) a current, human-approved refined output. This
+ * mirrors docs/REVISIONS.md's dependency gate closely enough to gate the
+ * button; the server's own plan is still the final word once the revision
+ * asset exists, and reports `blocked` with the real reason if this guess
+ * were ever wrong.
+ */
+const isRevisable = (item) => {
+  if (item.source) return true;
+  if (item.quality) return item.quality.review?.status === 'approved' && !!item.quality.check?.current;
+  return item.status === 'downloaded' && item.state === 'ok';
+};
 const activeJobFor = (item) => GEN.jobs.find((job) => ACTIVE_PHASES.has(job.phase) && job.project === item.project && job.keys.includes(item.key)) || null;
 const JOB_VERB = { generate: 'regenerating', resume: 'resuming', refresh: 'pulling upstream changes for', restore: 'restoring', revert: 'bringing back a previous generation of' };
 const PHASE_TEXT = { queued: 'queued', submitting: 'submitting to the provider', polling: 'waiting for the provider to finish', fetching: 'downloading the result', review: 'candidates are ready to review' };
@@ -1570,7 +1584,7 @@ function addAssetForm(style) {
   const form = el('form', 'edit');
   form.append(el('h3', null, 'New asset in ' + style.id));
   const id = el('input'); id.type = 'text'; id.placeholder = 'asset-id'; id.required = true; id.autocomplete = 'off';
-  id.pattern = '[^/\\]+';
+  id.pattern = '[^\\/\\\\]+';
   const prompt = el('textarea'); prompt.placeholder = 'What to generate. The style adds its prefix and suffix.'; prompt.required = true;
   const width = numberInput(null, 'style default'), height = numberInput(null, 'style default');
   const category = el('input'); category.type = 'text'; category.placeholder = 'optional subfolder';
@@ -1613,6 +1627,54 @@ function addAssetForm(style) {
   return form;
 }
 
+/**
+ * A new `image-to-image` revision of `item`, restricted to `item`'s own
+ * style (a revision's `from` resolves per style, and this button starts
+ * from one specific generation). `inpaint` needs a mask upload the gallery
+ * does not offer yet, so this form only ever creates `image-to-image`.
+ */
+function newRevisionForm(item) {
+  const pr = projectOf(item);
+  const form = el('form', 'edit');
+  form.append(el('h3', null, 'New revision of ' + item.assetId));
+  const id = el('input'); id.type = 'text'; id.placeholder = 'asset-id'; id.required = true; id.autocomplete = 'off';
+  id.pattern = '[^\\/\\\\]+';
+  const prompt = el('textarea'); prompt.placeholder = 'Edit instruction, e.g. "add snow on the roof".'; prompt.required = true;
+  const strength = el('input'); strength.type = 'number'; strength.min = '0'; strength.max = '1'; strength.step = '0.05'; strength.placeholder = 'provider default';
+  const row1 = el('div', 'row');
+  row1.append(field('new asset id', id), field('strength', strength, 'PixelLab rejects an explicit strength for image-to-image; leave this blank there.'));
+  form.append(row1, field('edit instruction', prompt, 'The style still adds its prefix and suffix.'));
+  const actions = el('div', 'actions');
+  const save = el('button', 'primary', 'Create revision'); save.type = 'submit';
+  const cancel = el('button', null, 'Cancel'); cancel.type = 'button'; cancel.onclick = () => { ui.editing = null; renderDrawer(); };
+  const msg = el('span', 'msg');
+  actions.append(save, cancel, msg);
+  form.append(actions);
+  form.onsubmit = async (e) => {
+    e.preventDefault();
+    save.disabled = true; msg.className = 'msg'; msg.textContent = 'saving…';
+    const revision = { mode: 'image-to-image', from: item.assetId };
+    if (strength.value.trim() !== '') revision.strength = Number(strength.value);
+    const asset = { prompt: prompt.value, styles: [item.styleId], revision };
+    try {
+      const body = { action: 'add-asset', assetId: id.value.trim(), expectedSha256: pr.manifestSha256, asset };
+      if (item.project) body.project = item.project;
+      snap = await postEdit(body);
+      const newId = (item.project ? item.project + ':' : '') + item.styleId + '/' + id.value.trim();
+      ui.editing = null;
+      ui.notice = { id: newId, text: 'Added to the manifest. Nothing is generated until you run pixelkiln gen.' };
+      render();
+      if (snap.items.some((i) => i.id === newId)) openItem(newId);
+    } catch (err) {
+      save.disabled = false;
+      msg.className = 'msg bad';
+      msg.textContent = err.message + (err.status === 409 ? ' Press Refresh.' : '');
+    }
+  };
+  setTimeout(() => id.focus(), 0);
+  return form;
+}
+
 function editForm(item) {
   const pr = projectOf(item);
   const a = item.asset;
@@ -1980,9 +2042,18 @@ function renderDrawer() {
     body.append(s);
   }
   const children = snap.items.filter((i) => i.revisionParentKey === item.key && i.project === item.project);
-  if (children.length) {
+  const reviseKey = 'revise:' + item.id;
+  const canRevise = canEdit && isRevisable(item);
+  if (children.length || canRevise) {
     const { s, dl } = section('Revisions from this asset');
     for (const c of children) row(dl, c.revision ? c.revision.mode : 'child', keyLink(item, c.key));
+    if (canRevise) {
+      const revise = el('button', ui.editing === reviseKey ? null : 'add', ui.editing === reviseKey ? 'Cancel' : '+ New revision');
+      revise.type = 'button';
+      revise.onclick = () => { ui.editing = ui.editing === reviseKey ? null : reviseKey; ui.notice = null; renderDrawer(); };
+      s.append(revise);
+      if (ui.editing === reviseKey) s.append(newRevisionForm(item));
+    }
     body.append(s);
   }
 

package/dist/index.cjs

@@ -188,6 +188,7 @@ __export(index_exports, {
   mountStyle: () => mountStyle,
   normalizeLockOutputPaths: () => normalizeLockOutputPaths,
   normalizeRefinementPalette: () => normalizeRefinementPalette,
+  normalizeTerrainTiles: () => normalizeTerrainTiles,
   normalizeTileRules: () => normalizeTileRules,
   openExternal: () => openExternal,
   openInEditor: () => openInEditor,
@@ -10486,6 +10487,25 @@ function normalizeTileRules(raw) {
     raw
   };
 }
+function normalizeTerrainTiles(metadata) {
+  if (!isRecord2(metadata) || !Array.isArray(metadata.terrainTiles)) return null;
+  const terrains = Array.isArray(metadata.terrainTypes) ? metadata.terrainTypes.filter((item) => typeof item === "string") : [];
+  if (terrains.length < 2) return null;
+  const masks = {};
+  metadata.terrainTiles.forEach((tile, index) => {
+    if (!isRecord2(tile) || !isRecord2(tile.corners)) return;
+    const corners = tile.corners;
+    const bit = (corner) => corners[corner] === terrains[0] ? 1 : 0;
+    masks[index] = bit("NW") << 3 | bit("NE") << 2 | bit("SW") << 1 | bit("SE");
+  });
+  return {
+    ruleType: "corner",
+    arity: 4,
+    terrains,
+    masks,
+    raw: metadata
+  };
+}
 function exportTileset(entry, spec, options) {
   let outputs = resolveSpecEntryOutputs(entry, spec);
   if (!outputs.length) throw new Error(`${spec.styleId}/${spec.assetId} has no downloaded outputs`);
@@ -10506,14 +10526,16 @@ function exportTileset(entry, spec, options) {
   }
   const metadata = entry.providerMetadata?.[entry.provider];
   const rawRules = isRecord2(metadata) ? metadata.tileRules : void 0;
-  const rules = normalizeTileRules(rawRules);
+  const terrainRules = normalizeTerrainTiles(metadata);
+  const rules = normalizeTileRules(rawRules) ?? terrainRules;
+  const providerRules = isRecord2(rawRules) ? rawRules : terrainRules ? metadata : null;
   const frames = packed.atlas.frames;
   const generic = buildGeneric(
     spec,
     options.imageName,
     packed.atlas,
     frames,
-    isRecord2(rawRules) ? rawRules : null,
+    providerRules,
     rules
   );
   if (options.format === "generic") {
@@ -10526,7 +10548,7 @@ function exportTileset(entry, spec, options) {
     };
   }
   assertUniformTiles(generic);
-  if ((rawRules !== void 0 || entry.tileFeature) && !rules) {
+  if ((rawRules !== void 0 || entry.tileFeature || entry.generator === "terrain") && !rules) {
     throw new Error(
       `${options.format} export needs recognized adjacency rules; use --format generic to retain this provider rule object without guessing`
     );
@@ -12341,7 +12363,19 @@ var NewAssetSchema = import_zod7.z.object({
   size: import_zod7.z.number().int().optional(),
   tags: import_zod7.z.array(import_zod7.z.string()).optional(),
   /** Restrict to these styles; empty or omitted means every style. */
-  styles: import_zod7.z.array(import_zod7.z.string().min(1)).optional()
+  styles: import_zod7.z.array(import_zod7.z.string().min(1)).optional(),
+  /**
+   * A controlled regeneration of another asset in the same manifest,
+   * instead of a fresh generation. `inpaint` needs a mask upload the
+   * gallery does not offer yet, so only `image-to-image` can be created
+   * here; hand-edit the manifest for the other modes.
+   */
+  revision: import_zod7.z.object({
+    mode: import_zod7.z.literal("image-to-image"),
+    /** Asset id of the parent this revises; must already exist. */
+    from: import_zod7.z.string().min(1),
+    strength: import_zod7.z.number().min(0).max(1).optional()
+  }).strict().optional()
 }).strict();
 var CANDIDATE_OPTION = {
   retrodiffusion: "numImages",
@@ -12507,6 +12541,9 @@ function applyEdit(raw, edit) {
       }
       asset2.styles = styles;
     }
+    if (edit.asset.revision && !Object.hasOwn(raw.assets, edit.asset.revision.from)) {
+      throw new ManifestEditError(`revision parent "${edit.asset.revision.from}" is not declared by the manifest`);
+    }
     raw.assets[edit.assetId] = asset2;
     return;
   }
@@ -15201,6 +15238,7 @@ async function workspaceStatus(ws, dir) {
   mountStyle,
   normalizeLockOutputPaths,
   normalizeRefinementPalette,
+  normalizeTerrainTiles,
   normalizeTileRules,
   openExternal,
   openInEditor,