@12ui/design 0.2.73 → 0.2.75

package/dist/mcp-slate-ui-script-dialog.js

@@ -1,24 +1,25 @@
 /**
- * The four dialogs of the workspace: Design (new options or more like this,
- * an optional steer note, and the inspiration selected in its tab), Edit (an
- * instruction and a scribble over the image), Branch (what to build) and
- * Convert (which format, with only the options that format has). Each is opened
- * by its button, confirmed by one verb (Generate, Apply, Send, Send) and closed
- * by Cancel or Escape; Select has no dialog.
+ * The three dialogs of the workspace: Edit (a drawing over the image, an
+ * optional instruction, or both), Branch (an optional description of what to
+ * build) and Convert (which format, with only the options that format has).
+ * Each is opened by its button, confirmed by one verb (Apply, Send, Send) and
+ * closed by Cancel or Escape; Select has no dialog, and Generate more is a
+ * panel, not a dialog (mcp-slate-ui-script-more.ts).
  *
- * Common rules: a title, fields, an error line (role alert, empty by default),
- * then Cancel and the primary. The primary keeps its label and disables while a
- * call is in flight; on success the dialog closes at once. One id is minted
- * when the dialog opens (the op id of Design and Edit, the hand-off id of
- * Branch and Convert), so a double click sends one request.
+ * Common rules: a title, fields, one line that says what will happen, an error
+ * line (role alert, empty by default), then Cancel and the primary. The
+ * primary keeps its label and disables while a call is in flight; on success
+ * the dialog closes at once. One id is minted when the dialog opens (the op id
+ * of Edit, the hand-off id of Branch and Convert), so a double click sends one
+ * request.
  *
- * Design and Edit start work through the run tool, which returns as soon as
- * the work is committed; Branch and Convert hand off to the agent through
- * sendHandoff. Nothing here shows or asks for money.
+ * Edit starts work through the run tool, which returns as soon as the work is
+ * committed; Branch and Convert hand off to the agent through sendHandoff.
+ * Nothing here shows or asks for money.
  */
 export const SLATE_UI_DIALOG = String.raw `
-  var DIALOG_TITLES = { design: COPY.design, edit: COPY.edit, branch: COPY.branch, convert: COPY.convert };
-  var DIALOG_VERBS = { design: COPY.generate, edit: COPY.apply, branch: COPY.send, convert: COPY.send };
+  var DIALOG_TITLES = { edit: COPY.edit, branch: COPY.branch, convert: COPY.convert };
+  var DIALOG_VERBS = { edit: COPY.apply, branch: COPY.send, convert: COPY.send };
 
   function field(labelText, control, id) {
     var wrap = el("div", "field");
@@ -34,11 +35,14 @@ export const SLATE_UI_DIALOG = String.raw `
     wrap.appendChild(control);
     return wrap;
   }
-  function textarea(id, rows, placeholder, max, onInput) {
+  // One muted line under a control: what it does, or what will happen.
+  function helpLine(text) { return el("p", "help", text); }
+  function textarea(id, rows, placeholder, max, onInput, ariaLabel) {
     var area = el("textarea");
     area.id = id;
     area.setAttribute("rows", String(rows));
     area.placeholder = placeholder;
+    area.setAttribute("aria-label", ariaLabel);
     area.setAttribute("maxlength", String(max));
     area.addEventListener("input", function () { onInput(area.value); updateDialogUi(); });
     return area;
@@ -69,12 +73,12 @@ export const SLATE_UI_DIALOG = String.raw `
   function openDialog(kind, opener) {
     if (state.dialog || !state.view) return;
     var v = selectedVersion();
-    if (kind !== "design" && !v) return;
+    if (!v) return;
     if (kind === "edit" && !v.editable) return;
     state.dialog = {
-      kind: kind, id: uuid4(), versionId: v ? v.versionId : null, opener: opener,
-      mode: "new", note: "", prompt: "", explanation: "",
-      format: CONVERT.choices[0].value, clean: "enhance", quality: "standard", width: "", layouts: "standard",
+      kind: kind, id: uuid4(), versionId: v.versionId, opener: opener,
+      prompt: "", explanation: "",
+      format: CONVERT.choices[0].value, quality: "standard", width: "", layouts: "standard",
       strokes: [], current: null, committing: false, error: "", els: {}
     };
     mountDialog();
@@ -88,17 +92,11 @@ export const SLATE_UI_DIALOG = String.raw `
   }
 
   // ---- what each dialog would send ----
-  // The one round action: the Design dialog and the Generate more panel both build it here. Only the panel sets a count.
-  function roundAction(request) {
-    var action = { kind: "round", mode: request.mode };
-    var note = (request.note || "").trim();
-    if (note) action.note = note;
-    if (request.count !== undefined) action.count = request.count;
-    if (request.mode === "like") action.fromVersionId = request.fromVersionId;
-    return action;
-  }
+  // The instruction is optional when the edit carries marks: a drawing alone is sent with no words and the server infers them.
   function editAction(d) {
-    var action = { kind: "edit", versionId: d.versionId, prompt: d.prompt.trim() };
+    var action = { kind: "edit", versionId: d.versionId };
+    var words = d.prompt.trim();
+    if (words) action.prompt = words;
     if (d.strokes.length > 0) action.strokes = d.strokes.map(function (s) { return s.map(function (p) { return [p[0], p[1]]; }); });
     return action;
   }
@@ -125,7 +123,7 @@ export const SLATE_UI_DIALOG = String.raw `
     var choice = convertChoice(d);
     // The hosted server has one engine and two outputs; nothing else is a choice.
     if (TARGET === "remote") return { engine: "local", output: choice.output };
-    if (choice.engine === "local") return { engine: "local", output: choice.output, cleanAssets: d.clean };
+    if (choice.engine === "local") return { engine: "local", output: choice.output };
     var options = { engine: "service", output: choice.output, model: d.quality };
     var width = widthOf(d);
     if (width.value !== null) options.width = width.value;
@@ -134,9 +132,9 @@ export const SLATE_UI_DIALOG = String.raw `
   }
   function dialogReady(d) {
     var v = ver(d.versionId);
-    if (d.kind === "design") return localImage().ready && (d.mode === "new" || pickable(v));
-    if (d.kind === "edit") return localImage().ready && !!v && v.editable && !!d.prompt.trim();
-    if (d.kind === "branch") return !!d.explanation.trim();
+    // An edit needs a drawing, words or both; Branch has no required field.
+    if (d.kind === "edit") return localImage().ready && !!v && v.editable && (d.strokes.length > 0 || !!d.prompt.trim());
+    if (d.kind === "branch") return true;
     return !!convertChoice(d) && widthOf(d).ok;
   }
 
@@ -150,10 +148,6 @@ export const SLATE_UI_DIALOG = String.raw `
       return sc;
     });
   }
-  // The one way a round starts: the selection is committed first, so the round uses the inspiration the person sees.
-  function startRound(opId, request) {
-    return whenSelectionSettled().then(function () { return runAction(roundAction(request), opId); });
-  }
   function commitDialog() {
     var d = state.dialog;
     if (!d || d.committing || !dialogReady(d)) return;
@@ -164,13 +158,13 @@ export const SLATE_UI_DIALOG = String.raw `
     var work;
     if (d.kind === "branch") work = sendHandoff("branch", version, d.id, { explanation: d.explanation.trim() });
     else if (d.kind === "convert") work = sendHandoff("convert", version, d.id, convertOptions(d));
-    else if (d.kind === "edit") {
+    else {
       var edited = cand(version.candidateId);
       work = editActionFor(d, version).then(function (action) { return runAction(action, d.id); }).then(function () {
         // The new version is shown the moment it lands.
         state.awaitEdit = { candidateId: version.candidateId, count: edited ? edited.versionIds.length : 0 };
       });
-    } else work = startRound(d.id, { mode: d.mode, note: d.note, fromVersionId: d.versionId });
+    }
     work.then(function () {
       closeDialog();
     }, function (err) {
@@ -182,26 +176,6 @@ export const SLATE_UI_DIALOG = String.raw `
   }
 
   // ---- the dialog's elements ----
-  function designBody(d, box) {
-    var v = ver(d.versionId);
-    var modes = [{ value: "new", label: COPY.newOptions }, { value: "like", label: COPY.moreLikeThis, disabled: !pickable(v) }];
-    box.appendChild(radioRow("mode", modes, d.mode, function (value) { d.mode = value; }));
-    box.appendChild(field(COPY.noteLabel, textarea("dialognote", 2, COPY.notePlaceholder, 600, function (value) { d.note = value; }), "dialognote"));
-    var line = el("div", "refline");
-    var chosen = currentSelected().slice(0, MAX_SELECTED);
-    if (chosen.length > 0) {
-      var thumbs = el("span", "refthumbs");
-      chosen.forEach(function (id) {
-        var img = el("img", "refmini empty");
-        img.alt = "";
-        thumbs.appendChild(img);
-        bindReference(img, id, "thumb");
-      });
-      line.appendChild(thumbs);
-    }
-    line.appendChild(el("span", "", chosen.length > 0 ? COPY.usingSelected : COPY.usingFresh));
-    box.appendChild(line);
-  }
   function editBody(d, box) {
     var v = ver(d.versionId);
     var wrap = el("div", "imgwrap");
@@ -215,16 +189,21 @@ export const SLATE_UI_DIALOG = String.raw `
     if (cached) img.src = cached;
     scribbleAttach(wrap, d);
     box.appendChild(wrap);
+    // Under the image: the hint that it can be drawn on, and the two drawing controls.
     var tools = el("div", "dialogtools");
+    tools.appendChild(el("p", "hint", COPY.scribbleHint));
     d.els.undo = button(COPY.undo, "", function () { scribbleUndo(d); });
     d.els.clear = button(COPY.clear, "", function () { scribbleClear(d); });
     tools.appendChild(d.els.undo);
     tools.appendChild(d.els.clear);
     box.appendChild(tools);
-    box.appendChild(field(COPY.editLabel, textarea("dialogedit", 3, COPY.editPlaceholder, 6000, function (value) { d.prompt = value; }), "dialogedit"));
+    box.appendChild(textarea("dialogedit", 3, COPY.editPlaceholder, 6000, function (value) { d.prompt = value; }, COPY.editAria));
+    d.els.help = helpLine("");
+    box.appendChild(d.els.help);
   }
   function branchBody(d, box) {
-    box.appendChild(field(COPY.branchLabel, textarea("dialogbranch", 4, COPY.branchPlaceholder, 2000, function (value) { d.explanation = value; }), "dialogbranch"));
+    box.appendChild(textarea("dialogbranch", 4, COPY.branchPlaceholder, 2000, function (value) { d.explanation = value; }, COPY.branchAria));
+    box.appendChild(helpLine(COPY.branchHelp));
   }
   function convertBody(d, box) {
     var select = el("select");
@@ -240,11 +219,14 @@ export const SLATE_UI_DIALOG = String.raw `
     if (service.childNodes.length > 0) select.appendChild(service);
     select.addEventListener("change", function () { d.format = select.value; updateDialogUi(); });
     box.appendChild(field(COPY.convertLabel, select, "dialogformat"));
-    // The hosted server builds from the image and has nothing else to ask: no assets, quality, width or layouts.
+    // One line that follows the choice: what the person gets.
+    d.els.formatHelp = helpLine("");
+    box.appendChild(d.els.formatHelp);
+    // The hosted server builds from the image and has nothing else to ask: no quality, width or layouts.
     if (TARGET === "remote") return;
-    // Only the options the chosen format has are shown; the rest are hidden, not disabled.
-    d.els.local = group(COPY.cleanLabel, radioRow("clean", [{ value: "crop", label: COPY.crop }, { value: "enhance", label: COPY.enhance }], d.clean, function (value) { d.clean = value; }));
+    // Only the options the chosen format has are shown; the rest are hidden, not disabled. Each says what it does in one line.
     d.els.quality = group(COPY.qualityLabel, radioRow("quality", [{ value: "fast", label: COPY.fast }, { value: "standard", label: COPY.standard }, { value: "pro", label: COPY.pro }], d.quality, function (value) { d.quality = value; }));
+    d.els.quality.appendChild(helpLine(COPY.qualityHelp));
     var width = el("input");
     width.type = "number";
     width.id = "dialogwidth";
@@ -254,8 +236,10 @@ export const SLATE_UI_DIALOG = String.raw `
     width.setAttribute("inputmode", "numeric");
     width.addEventListener("input", function () { d.width = width.value; updateDialogUi(); });
     d.els.width = field(COPY.widthLabel, width, "dialogwidth");
+    d.els.width.appendChild(helpLine(COPY.widthHelp));
     d.els.layouts = group(COPY.layoutsLabel, radioRow("layouts", [{ value: "standard", label: COPY.standard }, { value: "pro", label: COPY.pro }], d.layouts, function (value) { d.layouts = value; }));
-    [d.els.local, d.els.quality, d.els.width, d.els.layouts].forEach(function (node) { box.appendChild(node); });
+    d.els.layouts.appendChild(helpLine(COPY.layoutsHelp));
+    [d.els.quality, d.els.width, d.els.layouts].forEach(function (node) { box.appendChild(node); });
   }
 
   function mountDialog() {
@@ -269,8 +253,7 @@ export const SLATE_UI_DIALOG = String.raw `
     box.setAttribute("aria-modal", "true");
     box.setAttribute("aria-label", DIALOG_TITLES[d.kind]);
     box.appendChild(el("h2", "", DIALOG_TITLES[d.kind]));
-    if (d.kind === "design") designBody(d, box);
-    else if (d.kind === "edit") editBody(d, box);
+    if (d.kind === "edit") editBody(d, box);
     else if (d.kind === "branch") branchBody(d, box);
     else convertBody(d, box);
     d.els.alert = el("p", "alert");
@@ -296,15 +279,21 @@ export const SLATE_UI_DIALOG = String.raw `
     d.els.primary.disabled = d.committing || !dialogReady(d);
     // A dialog that cannot run on this Mac says why, in the same line an error would use.
     var local = localImage();
-    var blockedByLocal = (d.kind === "design" || d.kind === "edit") && !local.ready;
+    var blockedByLocal = d.kind === "edit" && !local.ready;
     d.els.alert.textContent = d.error || (blockedByLocal && local.reason ? local.reason : "");
     d.els.alert.classList.toggle("hidden", !d.els.alert.textContent);
     if (d.els.undo) d.els.undo.disabled = d.strokes.length === 0 || d.committing;
     if (d.els.clear) d.els.clear.disabled = d.strokes.length === 0 || d.committing;
-    if (d.kind === "convert" && TARGET !== "remote") {
+    if (d.els.help) {
+      var marksOnly = d.strokes.length > 0 && !d.prompt.trim();
+      d.els.help.textContent = marksOnly ? COPY.editHelpMarks : tpl(COPY.editHelp, { label: (ver(d.versionId) || {}).label || "" });
+    }
+    if (d.kind === "convert") {
       var choice = convertChoice(d);
+      d.els.formatHelp.textContent = (choice && CONVERT.descriptions[choice.value]) || "";
+    }
+    if (d.kind === "convert" && TARGET !== "remote") {
       var isLocal = !!choice && choice.engine === "local";
-      d.els.local.classList.toggle("hidden", !isLocal);
       d.els.quality.classList.toggle("hidden", isLocal);
       d.els.width.classList.toggle("hidden", isLocal);
       d.els.layouts.classList.toggle("hidden", isLocal || choice.output !== "html");

package/dist/mcp-slate-ui-script-dialog.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-dialog.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-dialog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwTxC,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-dialog.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-dialog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4SxC,CAAC"}

package/dist/mcp-slate-ui-script-inline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-inline.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inline.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAmN3B,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-inline.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inline.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAsN3B,CAAC"}

package/dist/mcp-slate-ui-script-inline.js

@@ -15,7 +15,6 @@ export const SLATE_UI_INLINE = String.raw `
     if (prev && prev.runDir !== view.runDir) {
       state.sel = { candidateId: null, versionId: null, followLatest: true };
       state.dialog = null;
-      state.wantEdit = null;
       resetMore();
       state.insp.local = null;
       state.awaitEdit = null;
@@ -53,8 +52,6 @@ export const SLATE_UI_INLINE = String.raw `
     $("app").classList.toggle("hidden", full);
     $("stage").classList.toggle("hidden", !full);
     if (full) renderStage(); else renderInline();
-    // Edit asked for from a thumbnail in the card: the workspace is showing now, so its dialog opens.
-    if (full) openWantedEdit();
     // A dialog that is open follows the view: what this Mac can do now, for one.
     if (state.dialog) updateDialogUi();
     syncMore();
@@ -86,6 +83,9 @@ export const SLATE_UI_INLINE = String.raw `
     wrap.textContent = "";
     wrap.classList.remove("note");
     wrap.style.removeProperty("--ar");
+    // The workspace's action row is as wide as the picture, so Select sits under its right edge: the shared parent carries the ratio too.
+    var shared = wrap.parentElement;
+    if (shared) shared.style.removeProperty("--ar");
     if (!c) return;
     if (!v || v.fileState !== "ok") {
       wrap.classList.add("note");
@@ -94,6 +94,7 @@ export const SLATE_UI_INLINE = String.raw `
       return;
     }
     wrap.style.setProperty("--ar", String(v.width / v.height));
+    if (shared) shared.style.setProperty("--ar", String(v.width / v.height));
     var img = el("img", "heroimg empty");
     img.alt = COPY.versionPrefix + v.label;
     img.setAttribute("draggable", "false");
@@ -157,13 +158,15 @@ export const SLATE_UI_INLINE = String.raw `
     var sel = selectedVersion();
     setIfChanged($("hero"), heroSignature(c, sel), function (node) { heroInto(node, c, sel); });
     var strip = $("strip");
-    // Where keyboard focus sits among the strip's buttons (a thumbnail, its two controls, the tile), so a rebuild can put it back.
+    // Where keyboard focus sits among the strip's buttons (the thumbnails), so a rebuild can put it back.
     var focusAt = strip.contains(document.activeElement) ? Array.prototype.indexOf.call(strip.querySelectorAll("button"), document.activeElement) : -1;
     var options = inlineCandidates();
     var rebuilt = setIfChanged(strip, JSON.stringify([state.sel.candidateId, options.map(thumbSignature)]), function (node) {
-      options.forEach(function (x) { node.appendChild(thumbCell(x, "thumbbtn")); });
-      node.appendChild(moreTile());
+      options.forEach(function (x) { node.appendChild(thumbButton(x, "thumbbtn")); });
     });
+    // The Generate more tile is pinned beside the strip, outside its scroll, so it is never pushed out of view; built once.
+    var wrap = $("stripwrap");
+    if (!wrap.querySelector(".moretile")) wrap.appendChild(moreTile());
     // Choosing a thumbnail rebuilds the strip: keep keyboard focus at the same place in it.
     var stripButtons = strip.querySelectorAll("button");
     if (rebuilt && focusAt >= 0 && stripButtons[focusAt]) stripButtons[focusAt].focus();

package/dist/mcp-slate-ui-script-inline.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-inline.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inline.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmNxC,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-inline.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inline.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsNxC,CAAC"}

package/dist/mcp-slate-ui-script-inspiration.d.ts

@@ -5,8 +5,9 @@
  * produced its options. Every reference is a toggle. The selection lives in
  * the view (`inspiration.selected`, at most eight, in click order) and is
  * written whole through the inspiration tool, one write in flight at a time,
- * last click wins locally; the next Design round reads it at commit. Nothing
- * in this tab starts work.
+ * last click wins locally; the next round reads it at commit. Nothing in this
+ * tab starts work. While a search runs the newest-search slot is skeleton
+ * tiles; a search with no results says so.
  */
 export declare const SLATE_UI_INSPIRATION: string;
 //# sourceMappingURL=mcp-slate-ui-script-inspiration.d.ts.map

package/dist/mcp-slate-ui-script-inspiration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-inspiration.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inspiration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,QA4MhC,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-inspiration.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inspiration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,QA+NhC,CAAC"}

package/dist/mcp-slate-ui-script-inspiration.js

@@ -5,8 +5,9 @@
  * produced its options. Every reference is a toggle. The selection lives in
  * the view (`inspiration.selected`, at most eight, in click order) and is
  * written whole through the inspiration tool, one write in flight at a time,
- * last click wins locally; the next Design round reads it at commit. Nothing
- * in this tab starts work.
+ * last click wins locally; the next round reads it at commit. Nothing in this
+ * tab starts work. While a search runs the newest-search slot is skeleton
+ * tiles; a search with no results says so.
  */
 export const SLATE_UI_INSPIRATION = String.raw `
   var MAX_SELECTED = 8;
@@ -44,10 +45,11 @@ export const SLATE_UI_INSPIRATION = String.raw `
     return state.insp.local || (state.view && state.view.inspiration ? state.view.inspiration.selected : []);
   }
   function refMeta(id) { return (state.view.references && state.view.references[id]) || null; }
-  function refName(id) {
+  function refDescription(id) {
     var m = refMeta(id);
-    return COPY.referencePrefix + String((m && m.description) || id).slice(0, 40);
+    return String((m && m.description) || id).slice(0, 40);
   }
+  function refName(id) { return COPY.referencePrefix + refDescription(id); }
   function newestSearch() {
     var searches = (state.view.inspiration && state.view.inspiration.searches) || [];
     var best = null;
@@ -105,7 +107,7 @@ export const SLATE_UI_INSPIRATION = String.raw `
       waiting.forEach(function (resolve) { resolve(); });
     });
   }
-  // Resolves when no selection write is in flight, so a Design round commits the selection the person sees.
+  // Resolves when no selection write is in flight, so a round commits the selection the person sees.
   function whenSelectionSettled() {
     if (!state.insp.writing) return Promise.resolve();
     return new Promise(function (resolve) { state.insp.waiters.push(resolve); });
@@ -119,11 +121,15 @@ export const SLATE_UI_INSPIRATION = String.raw `
     var q = state.query.trim();
     if (!q || state.insp.searching || !state.view) return;
     state.insp.searching = true;
-    setInspStatus("", "");
+    state.insp.noMatch = "";
+    setInspStatus(COPY.searching, "");
     renderAll();
     callTool(TOOLS.inspire, { runDir: state.view.runDir, query: q }).then(function (result) {
       var sc = result.structuredContent || {};
       if (sc.view) applyView(sc.view, true);
+      setInspStatus("", "");
+      var found = sc.search || newestSearch();
+      if (found && found.referenceIds.length === 0) state.insp.noMatch = found.searchId;
     }, function (err) {
       setInspStatus(err.code === "rate_limited" && err.retryAfterSeconds !== undefined ? tpl(COPY.tryAgain, { n: err.retryAfterSeconds }) : tpl(COPY.searchFailed, { message: errText(err) }), "err");
     }).then(function () { state.insp.searching = false; renderAll(); });
@@ -134,7 +140,8 @@ export const SLATE_UI_INSPIRATION = String.raw `
     var b = button("", "refbtn");
     b.setAttribute("aria-label", refName(id));
     b.setAttribute("data-ref", id);
-    var img = el("img", "thumb empty");
+    // The picture's own skeleton shows until it lands, so a tile that has arrived never flashes a grey square.
+    var img = el("img", "thumb empty shimmer");
     img.alt = "";
     b.appendChild(img);
     bindReference(img, id, "thumb");
@@ -156,11 +163,23 @@ export const SLATE_UI_INSPIRATION = String.raw `
     sec.appendChild(grid);
     return sec;
   }
+  // The same tiles as the results, at the same size, where the results will land.
+  var SKELETON_TILES = 12;
+  function skeletonSection() {
+    var sec = el("section", "refsec");
+    var grid = el("div", "refgrid");
+    for (var i = 0; i < SKELETON_TILES; i++) grid.appendChild(el("div", "skeleton shimmer"));
+    sec.appendChild(grid);
+    return sec;
+  }
   function buildResults(box) {
     var v = state.view;
     var any = false;
     var search = newestSearch();
-    if (search && search.referenceIds.length > 0) { box.appendChild(refSection("", "", search.referenceIds)); any = true; }
+    // The newest search's slot: skeleton tiles while it runs, else its references, or the line that it found none.
+    if (state.insp.searching) { box.appendChild(skeletonSection()); any = true; }
+    else if (search && search.referenceIds.length === 0 && state.insp.noMatch === search.searchId) { box.appendChild(el("div", "placeholder", COPY.inspirationNoMatches)); any = true; }
+    else if (search && search.referenceIds.length > 0) { box.appendChild(refSection("", "", search.referenceIds)); any = true; }
     v.rounds.slice().sort(function (a, b) { return b.index - a.index; }).forEach(function (round) {
       if (round.referenceIds.length === 0) return;
       box.appendChild(refSection(COPY.roundPrefix + round.index, roundTitle(round), round.referenceIds));
@@ -206,7 +225,8 @@ export const SLATE_UI_INSPIRATION = String.raw `
     syncSearchButton(pane);
     var v = state.view;
     var search = newestSearch();
-    var sig = JSON.stringify([search && [search.searchId, search.referenceIds], v.rounds.map(function (r) { return [r.index, r.kind, r.fromVersionId, r.referenceIds]; }), v.references]);
+    pane.__results.setAttribute("aria-busy", state.insp.searching ? "true" : "false");
+    var sig = JSON.stringify([state.insp.searching, state.insp.noMatch, search && [search.searchId, search.referenceIds], v.rounds.map(function (r) { return [r.index, r.kind, r.fromVersionId, r.referenceIds]; }), v.references]);
     setIfChanged(pane.__results, sig, buildResults);
     var chosen = currentSelected();
     var buttons = pane.__results.querySelectorAll(".refbtn");

package/dist/mcp-slate-ui-script-inspiration.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-inspiration.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inspiration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4M7C,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-inspiration.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inspiration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+N7C,CAAC"}

package/dist/mcp-slate-ui-script-more.d.ts

@@ -1,22 +1,24 @@
 /**
  * Generate more: the last tile of the thumbnails (the card's strip, the
  * workspace's selection) and the panel it opens directly below them. The tile
- * is an empty, very light thumbnail-sized box with a plus and no words; the
- * panel is the heading, an optional note, how many (a segmented control) and
- * Generate or Cancel. Clicking the tile again, Cancel or Escape collapses it.
+ * is a dashed, thumbnail-sized box with a plus and the words Generate more, pinned outside any scroll so it is always in view; the
+ * panel is the only way to start a round, and it says what it will do:
  *
- * Generate starts a round through startRound, the very function the Design
- * dialog uses for New options, so the run tool, the mode, the note and the
- * selected inspiration are the same; the panel only adds the count.
+ * - a heading and one helper line that follows the state (fresh references,
+ *   the selected inspiration, or close to the shown design);
+ * - a switch, with a picture of the design at its left, "Based on <code>", off by default: off draws new options, on
+ *   draws options close to the design that is shown (mode "like" from the
+ *   shown version at the moment of Generate);
+ * - the selected inspiration as small chips, each with a remove button that is
+ *   the same selection write as the Inspiration tab's toggle (adding is done
+ *   in that tab);
+ * - an optional note, how many (1, 2, 4, 8 or 12, default 4) and Cancel and
+ *   Generate.
  *
- * The same panel serves a thumbnail's plus (mcp-slate-ui-script-thumbtools.ts):
- * "More like E2", with a tiny picture of that design, starts a round in mode
- * "like" from that design's latest version. The tile opens the plain panel
- * (mode "new"); opening either replaces the other, so neither carries the
- * other's reference. While a
- * round runs (or the request is in flight) the tile is off; the new round's
- * pending options are already in the thumbnails, because the returned view
- * carries them.
+ * Clicking the tile again, Cancel or Escape collapses it. While a round runs
+ * (or the request is in flight) the tile is off; the new round's pending
+ * options are already in the thumbnails, because the returned view carries
+ * them.
  *
  * In the card the panel takes its room from the large image rather than
  * growing the frame. The host grows the frame downward and does not scroll

package/dist/mcp-slate-ui-script-more.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-more.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-more.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,aAAa,QAmMzB,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-more.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-more.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,aAAa,QAiQzB,CAAC"}