@12ui/design 0.2.80 → 0.2.82

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

@@ -1,63 +1,184 @@
 import { PUBLIC_CORPUS_MAX_COUNT } from './corpus-access.js';
 import { SLATE_UI_INSPIRATION_COLLAGE } from './mcp-slate-ui-script-inspiration-collage.js';
+import { SLATE_UI_INSPIRATION_GALLERY } from './mcp-slate-ui-script-inspiration-gallery.js';
 import { SLATE_UI_INSPIRATION_GRID } from './mcp-slate-ui-script-inspiration-grid.js';
 /**
- * How many references the Inspiration tab asks one search for: the most the free corpus returns for one query (the
- * public tier's cap, which both servers' inspire tools also cap at). The corpus has no paging, so this is all one search
- * can show; the tab says so next to the results.
- */
-export const SLATE_INSPIRATION_SEARCH_COUNT = PUBLIC_CORPUS_MAX_COUNT;
-/**
- * The longest words one search takes, in characters (code points): both servers' inspire tools refuse longer. A round
- * searches with the whole brief and its note, which can be longer, so the box shows the round's words in full and the
- * search takes their first 500 characters, cut at a space, and the tab says so.
+ * How many references one Inspiration search asks for, per server: the hosted server's searches carry a depth grant
+ * and return a window the grid reveals a page at a time as the person scrolls (`SLATE_LIMITS.searchCountMax` there);
+ * the local plugin asks the public tier, which returns at most 24.
  */
+export const SLATE_INSPIRATION_SEARCH_COUNT = { remote: 96, local: PUBLIC_CORPUS_MAX_COUNT };
+/** The longest words one search takes, in characters (code points): both servers' inspire tools refuse longer. */
 export const SLATE_INSPIRATION_QUERY_CHARS = 500;
 /**
- * The tabs (Designs and Inspiration, in the card and the workspace) and the
- * Inspiration tab's words and work, which are the same in both places: the
- * search box, the search, and the selection. The tab's grid, its badges and
- * Generate are in mcp-slate-ui-script-inspiration-grid.ts.
+ * The shell's shared parts and the Inspiration tab's words and work, the same in the card and the workspace:
  *
- * - The search box opens with the words that produced this workspace's
- *   references: the newest round's own search words, which the server states
- *   in `inspiration.roundQueries` (stored or derived, never searched again),
- *   else the newest recorded search. A line under it says whose words they are,
- *   and when rounds searched different words, that these are the newest. Once
- *   the person types, the box is theirs.
- * - The grid shows the search of the words in the box. When the record has no
- *   search of the newest round's words, opening the tab runs that one search
- *   (free, at most once per workspace and words; an identical search is
- *   answered from the record by both servers). Every search asks for the most
- *   one search returns.
- * - 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 round reads it at commit. Nothing here starts
- *   a round: Generate does, through the same request as Generate more.
+ * - The prompt card: the screen's one input, an expanding field above the tabs with Search inside its right edge,
+ *   showing the workspace's prompt (`brief.concept`). Its words are both the design prompt and the inspiration search:
+ *   Search (or Enter; Shift+Enter is a new line) searches with them, keeps the picks, and saves them as the prompt.
+ *   What the person types is theirs until the server's prompt matches it; the next round they start, or the Continue
+ *   of a round that waits for them, carries it (`action.brief`), and the agent is told when they leave the field or
+ *   search with it.
+ * - The tabs, in flow order: Inspiration, References, Designs. Moving on to Designs while a round waits for its
+ *   references continues it with the picks (mcp-slate-ui-script-pause.ts).
+ * - The search the grid shows: the one the person ran, else the newest recorded search (on the hosted server the root
+ *   round's own search, recorded when the workspace was made); a workspace with no search yet searches the newest
+ *   round's words once. Every search asks for the most one search returns.
+ * - The selection: every reference is a toggle. Outside a pause the selection lives in the view
+ *   (`inspiration.selected`, at most eight, in click order), written whole through the inspiration tool, one write in
+ *   flight at a time, last click wins locally; the next round reads it at commit. While a round waits, a toggle changes
+ *   that round's references instead (the pause's own list).
+ * - The tab row says how many are selected, quietly, at its right while Inspiration or References is open.
+ * - The References tab (mcp-slate-ui-script-references.ts) reuses the gallery, the large view and the tray.
+ *
+ * The grid, the tray and Generate are in mcp-slate-ui-script-inspiration-grid.ts; the gallery and its large view in
+ * mcp-slate-ui-script-inspiration-gallery.ts.
  */
-const SEARCH_AND_SELECTION = String.raw `
+const SHELL_SEARCH_AND_SELECTION = String.raw `
   var MAX_SELECTED = 8;
-  var SEARCH_COUNT = ${JSON.stringify(SLATE_INSPIRATION_SEARCH_COUNT)};
+  var SEARCH_COUNT = TARGET === "remote" ? ${JSON.stringify(SLATE_INSPIRATION_SEARCH_COUNT.remote)} : ${JSON.stringify(SLATE_INSPIRATION_SEARCH_COUNT.local)};
   var QUERY_CHARS = ${JSON.stringify(SLATE_INSPIRATION_QUERY_CHARS)};
-  // Per workspace: whether the person typed in the box, the search the grid shows, the automatic searches already asked.
+  var TABS = ["inspiration", "references", "designs"];
+  // Per workspace: the search the grid shows, the automatic searches already asked.
   state.insp.runDir = null;
-  state.insp.typed = false;
-  state.insp.shownQuery = null;
   state.insp.searchId = "";
   state.insp.auto = {};
   state.insp.generating = false;
+  state.brief = { runDir: null, text: "", edited: false, told: "" };
+
+  // ---- words ----
+  // Two sets of words are the same search when both servers would key them alike: whitespace collapsed, case ignored.
+  function norm(text) { return String(text || "").replace(/\s+/g, " ").trim().toLowerCase(); }
+  function collapsed(text) { return String(text || "").replace(/\s+/g, " ").trim(); }
+  // What one search can take of these words: all of them, or the first QUERY_CHARS characters, cut at the last space.
+  function searchable(text) {
+    var chars = Array.from(collapsed(text));
+    if (chars.length <= QUERY_CHARS) return chars.join("");
+    var cut = chars.slice(0, QUERY_CHARS).join("");
+    var space = cut.lastIndexOf(" ");
+    return (chars[QUERY_CHARS] === " " || space < 0 ? cut : cut.slice(0, space)).trim();
+  }
+
+  // ---- an expanding field: one line, growing with its words up to a cap (__max px), then scrolling ----
+  // A field with __fold shows at most two lines, faded, until it has focus (a click gives it focus): then it opens to its cap.
+  var pointerDown = false;
+  document.addEventListener("pointerdown", function () { pointerDown = true; }, true);
+  document.addEventListener("pointerup", function () { pointerDown = false; }, true);
+  function fitField(field) {
+    if (!field.isConnected || field.offsetParent === null) return;
+    field.style.height = "auto";
+    if (!(field.scrollHeight > 0)) { field.style.height = ""; return; }
+    var max = field.__max || 200;
+    var want = field.scrollHeight + (field.offsetHeight - field.clientHeight);
+    var folded = !!field.__fold && document.activeElement !== field;
+    if (folded) {
+      var cs = getComputedStyle(field);
+      var fold = 2 * parseFloat(cs.lineHeight) + parseFloat(cs.paddingTop);
+      if (fold > 0 && fold < max) max = Math.ceil(fold);
+    }
+    field.style.height = Math.min(want, max) + "px";
+    field.style.overflowY = want > max && !folded ? "auto" : "hidden";
+    field.classList.toggle("folded", folded && want > max);
+  }
+
+  // ---- the design prompt ----
+  function briefConcept() { return (state.view && state.view.brief && state.view.brief.concept) || ""; }
+  function briefFields() { return document.querySelectorAll("textarea.brief"); }
+  function syncBrief() {
+    var b = state.brief;
+    if (!state.view) return;
+    if (b.runDir !== state.view.runDir) { b.runDir = state.view.runDir; b.edited = false; b.told = ""; }
+    if (b.edited && norm(b.text) === norm(briefConcept())) b.edited = false;
+    if (!b.edited) b.text = briefConcept();
+    var fields = briefFields();
+    for (var i = 0; i < fields.length; i++) {
+      if (fields[i] !== document.activeElement && fields[i].value !== b.text) fields[i].value = b.text;
+      fitField(fields[i]);
+    }
+    syncPromptButtons();
+  }
+  // The agent reads the workspace's prompt from the server; until the next round carries the edit, it is told here.
+  function briefMessage(words) { return "Design workspace: the person edited the design prompt on the screen. The next round they start draws from it: " + words; }
+  function tellBrief() {
+    var b = state.brief;
+    var words = collapsed(b.text);
+    if (!b.edited || !words || b.told === words) return;
+    b.told = words;
+    updateModelContext(briefMessage(words));
+  }
+  function bindBrief(field) {
+    field.maxLength = 2000;
+    field.__max = 176;
+    field.__fold = true;
+    field.addEventListener("input", function () {
+      var b = state.brief;
+      b.text = field.value;
+      b.edited = norm(field.value) !== norm(briefConcept());
+      var fields = briefFields();
+      for (var i = 0; i < fields.length; i++) { if (fields[i] !== field) fields[i].value = field.value; fitField(fields[i]); }
+      syncPromptButtons();
+    });
+    field.addEventListener("keydown", function (e) {
+      if (e.key === "Enter" && !e.shiftKey && !e.isComposing) { e.preventDefault(); submitPrompt(); }
+    });
+    field.addEventListener("focus", function () { fitField(field); });
+    // A press that began elsewhere (a tab) lets go before the card folds, so the click still lands where it began.
+    field.addEventListener("blur", function () {
+      tellBrief();
+      if (!pointerDown) { fitField(field); return; }
+      document.addEventListener("pointerup", function () { setTimeout(function () { fitField(field); }, 0); }, { capture: true, once: true });
+    });
+  }
+  function buildBriefField() {
+    var wrap = el("div", "briefwrap");
+    var field = el("textarea", "brief");
+    field.setAttribute("rows", "1");
+    field.spellcheck = false;
+    field.placeholder = t("briefPlaceholder");
+    field.setAttribute("aria-label", t("briefLabel"));
+    field.value = state.brief.text;
+    bindBrief(field);
+    wrap.appendChild(field);
+    wrap.appendChild(button(t("search"), "primary promptgo", submitPrompt));
+    return wrap;
+  }
+  // The prompt's button searches with the prompt's words: off while there are none or a search is in flight.
+  function syncPromptButtons() {
+    var off = !searchable(state.brief.text) || !!state.insp.searching || !state.view;
+    var buttons = document.querySelectorAll(".promptgo");
+    for (var i = 0; i < buttons.length; i++) buttons[i].disabled = off;
+  }
+  // Search with the prompt: the picks stay, the words become the design prompt, and the results show in Inspiration.
+  function submitPrompt() {
+    var q = searchable(state.brief.text);
+    if (!q || state.insp.searching || !state.view) return;
+    tellBrief();
+    if (state.tab === "designs") {
+      if (pause.opId) pause.autoTab = false;
+      setTab("inspiration");
+    }
+    runSearch(q);
+  }
+  // A request that starts drawing carries the prompt the person edited, so the server adopts it first.
+  function withBrief(action) {
+    var words = collapsed(state.brief.text);
+    if (state.brief.edited && words) action.brief = Array.from(words).slice(0, 2000).join("");
+    return action;
+  }
+  bindBrief($("brief"));
+  $("briefgo").addEventListener("click", submitPrompt);
 
+  // ---- the tabs ----
   // A tab strip for the workspace header. The card's own strip is static markup; both carry data-tab.
   function buildTabs() {
     var tabs = el("div", "tabs");
     tabs.setAttribute("role", "tablist");
     tabs.setAttribute("aria-label", t("title"));
-    [["designs", t("tabDesigns")], ["inspiration", t("tabInspiration")]].forEach(function (t) {
-      var b = button(t[1], "tab");
+    [["inspiration", t("tabInspiration")], ["references", t("tabReferences")], ["designs", t("tabDesigns")]].forEach(function (pair) {
+      var b = button(pair[1], "tab");
       b.setAttribute("role", "tab");
-      b.setAttribute("data-tab", t[0]);
-      b.setAttribute("aria-selected", state.tab === t[0] ? "true" : "false");
+      b.setAttribute("data-tab", pair[0]);
+      b.setAttribute("aria-selected", state.tab === pair[0] ? "true" : "false");
       bindTab(b);
       tabs.appendChild(b);
     });
@@ -66,26 +187,56 @@ const SEARCH_AND_SELECTION = String.raw `
   function syncTabs() {
     var tabs = document.querySelectorAll("[data-tab]");
     for (var i = 0; i < tabs.length; i++) tabs[i].setAttribute("aria-selected", tabs[i].getAttribute("data-tab") === state.tab ? "true" : "false");
+    // How many are picked, quietly at the row's right, while the person picks them (Inspiration and References).
+    var n = state.view && state.tab !== "designs" ? activeSelection().length : 0;
+    var words = n > 0 ? t("selectedCount", { n: n }) : "";
+    var counts = document.querySelectorAll("[data-selcount]");
+    for (var c = 0; c < counts.length; c++) if (counts[c].textContent !== words) counts[c].textContent = words;
   }
   function setTab(tab) {
-    if ((tab !== "designs" && tab !== "inspiration") || state.tab === tab) return;
+    if (TABS.indexOf(tab) < 0 || state.tab === tab) return;
+    // Moving on to Designs while a round waits for its references: it is drawn from the picks the person sees.
+    if (tab === "designs" && pauseActive()) continuePause();
     state.tab = tab;
     syncTabs();
     if (state.view) renderAll();
   }
-  function bindTab(b) { b.addEventListener("click", function () { setTab(b.getAttribute("data-tab")); }); }
+  function bindTab(b) {
+    b.addEventListener("click", function () {
+      // The person chose a tab: the pause never moves them again.
+      if (pause.opId) pause.autoTab = false;
+      setTab(b.getAttribute("data-tab"));
+    });
+  }
   Array.prototype.forEach.call(document.querySelectorAll("[data-tab]"), bindTab);
 
   // ---- what the view says about references ----
   function currentSelected() {
     return state.insp.local || (state.view && state.view.inspiration ? state.view.inspiration.selected : []);
   }
+  // The picks the next drawing uses: a waiting round's own list, else the selection.
+  function activeSelection() { return pauseActive() ? pauseChosen() : currentSelected(); }
   function refMeta(id) { return (state.view.references && state.view.references[id]) || null; }
   function refDescription(id) {
     var m = refMeta(id);
-    return String((m && m.description) || id).slice(0, 40);
+    var site = m ? null : siteById(id);
+    var named = (m && m.description) || (site && site.title);
+    // A reference with no words reads as its place in the list, never as its id.
+    return String(named || Math.max(1, Object.keys(state.view.references || {}).indexOf(id) + 1)).slice(0, 40);
   }
   function refName(id) { return t("referenceName", { description: refDescription(id) }); }
+  // A reference as the gallery shows it: straight from the public rendition origin when the server gave its URLs,
+  // else through the reference tool (a logo reference, or a workspace recorded before the URLs).
+  function refItem(id) {
+    var site = refMeta(id) ? null : siteById(id);
+    if (site) return siteItem(site);
+    var m = refMeta(id) || {};
+    var item = { id: id, label: refName(id), title: m.description || "", width: m.width || null, height: m.height || null, aspect: m.aspect || "landscape",
+      thumbUrl: m.thumbUrl || null, imageUrl: m.refUrl || m.thumbUrl || null, srcset: "" };
+    if (item.thumbUrl && m.refUrl) item.srcset = item.thumbUrl + " 384w, " + m.refUrl + " 1280w";
+    if (!item.thumbUrl) item.load = function (img, size) { bindReference(img, id, size); };
+    return item;
+  }
   function searchList() { return (state.view.inspiration && state.view.inspiration.searches) || []; }
   function newestSearch() {
     var searches = searchList();
@@ -100,88 +251,29 @@ const SEARCH_AND_SELECTION = String.raw `
     if (round.kind === "like") { var from = ver(round.fromVersionId); return t("likeTitle", { label: from ? from.label : "" }); }
     return "";
   }
-
-  // ---- whose words are in the box ----
-  // Two sets of words are the same search when both servers would key them alike: whitespace collapsed, case ignored.
-  function norm(text) { return String(text || "").replace(/\s+/g, " ").trim().toLowerCase(); }
-  function collapsed(text) { return String(text || "").replace(/\s+/g, " ").trim(); }
-  // What one search can take of these words: all of them, or the first QUERY_CHARS characters, cut at the last space.
-  function searchable(text) {
-    var chars = Array.from(collapsed(text));
-    if (chars.length <= QUERY_CHARS) return chars.join("");
-    var cut = chars.slice(0, QUERY_CHARS).join("");
-    var space = cut.lastIndexOf(" ");
-    return (chars[QUERY_CHARS] === " " || space < 0 ? cut : cut.slice(0, space)).trim();
-  }
-  function tooLong(text) { return Array.from(collapsed(text)).length > QUERY_CHARS; }
-  // The newest round's search words, the rounds that searched them, and the rounds that searched other words.
+  // The newest round's search words, as the server states them (stored or derived, never searched again).
   function roundWords() {
     var queries = (state.view.inspiration && state.view.inspiration.roundQueries) || [];
-    if (queries.length === 0) return null;
-    var latest = queries.reduce(function (a, b) { return b.roundIndex > a.roundIndex ? b : a; });
-    var key = norm(latest.query);
-    var byIndex = function (a, b) { return a - b; };
-    return {
-      query: latest.query,
-      same: queries.filter(function (q) { return norm(q.query) === key; }).map(function (q) { return q.roundIndex; }).sort(byIndex),
-      other: queries.filter(function (q) { return norm(q.query) !== key; }).map(function (q) { return q.roundIndex; }).sort(byIndex)
-    };
-  }
-  function defaultQuery() {
-    var words = roundWords();
-    if (words) return words.query;
-    var newest = newestSearch();
-    return newest ? newest.query : "";
-  }
-  function howText() {
-    var shown = norm(state.query);
-    if (!shown) return "";
-    var words = roundWords();
-    var line = "";
-    if (words && norm(words.query) === shown) {
-      line = words.other.length === 0
-        ? t("queryFrom", { count: words.same.length, rounds: listOf(words.same) })
-        : t("queryNewestOthers", { count: words.same.length, rounds: listOf(words.same), otherCount: words.other.length, others: listOf(words.other) });
-    } else {
-      var newest = newestSearch();
-      if (!state.insp.typed && newest && norm(newest.query) === shown) line = t("queryLastSearch");
-    }
-    if (tooLong(state.query)) line = sentences(line, t("queryCut", { n: QUERY_CHARS }));
-    return line;
-  }
-  // A new workspace starts clean; until the person types, the box follows the workspace's own words, and the grid with it.
-  function syncQuery() {
-    var v = state.view;
-    var i = state.insp;
-    if (i.runDir !== v.runDir) {
-      i.runDir = v.runDir;
-      i.typed = false;
-      i.shownQuery = null;
-      i.searchId = "";
-      i.noMatch = "";
-    }
-    if (i.typed) return;
-    var words = defaultQuery();
-    if (norm(words) !== norm(state.query)) { i.shownQuery = null; i.searchId = ""; }
-    state.query = words;
+    if (queries.length === 0) return "";
+    return queries.reduce(function (a, b) { return b.roundIndex > a.roundIndex ? b : a; }).query;
   }
 
-  // ---- the search the grid shows: the one the person ran, else the record's search of the words in the box ----
-  function findSearch(words) {
-    var key = norm(words);
-    var hit = null;
-    searchList().forEach(function (s) { if (norm(s.query) === key) hit = s; });
-    return hit;
-  }
+  // ---- the search the grid shows: the one the person ran, else the newest recorded search ----
   function shownSearch() {
     var i = state.insp;
     var ran = i.searchId ? searchList().filter(function (s) { return s.searchId === i.searchId; })[0] : null;
-    if (ran) return ran;
-    var words = i.shownQuery !== null ? i.shownQuery : defaultQuery();
-    return words ? findSearch(searchable(words)) : newestSearch();
+    return ran || newestSearch();
+  }
+  // A new workspace starts clean: the grid follows its own newest search.
+  function syncSearchRun() {
+    var i = state.insp;
+    if (i.runDir === state.view.runDir) return;
+    i.runDir = state.view.runDir;
+    i.searchId = "";
+    i.noMatch = "";
   }
 
-  // ---- the status line of this tab ----
+  // ---- the status line of this tab: what went wrong ----
   function setInspStatus(text, kind) {
     var nodes = document.querySelectorAll("[data-istatus]");
     for (var i = 0; i < nodes.length; i++) { nodes[i].textContent = text || ""; nodes[i].className = "status" + (kind ? " " + kind : ""); }
@@ -233,24 +325,16 @@ const SEARCH_AND_SELECTION = String.raw `
   }
 
   // ---- search ----
-  function syncSearchButton(pane) {
-    if (pane.__search) pane.__search.disabled = !state.query.trim() || state.insp.searching;
-  }
-  function doSearch() {
-    var q = searchable(state.query);
-    if (!q || state.insp.searching || !state.view) return;
-    runSearch(q);
-  }
   function runSearch(q) {
     var i = state.insp;
     i.searching = true;
     i.noMatch = "";
-    setInspStatus(t("searching"), "");
+    setInspStatus("", "");
     renderAll();
     callTool(TOOLS.inspire, { runDir: state.view.runDir, query: q, count: SEARCH_COUNT }).then(function (result) {
       var sc = result.structuredContent || {};
       // The grid shows what this search found from now on, even when the view's newest search is another one.
-      if (sc.search) { i.searchId = sc.search.searchId; i.shownQuery = sc.search.query; }
+      if (sc.search) i.searchId = sc.search.searchId;
       if (sc.view) applyView(sc.view, true);
       setInspStatus("", "");
       var found = sc.search || newestSearch();
@@ -259,19 +343,18 @@ const SEARCH_AND_SELECTION = String.raw `
       setInspStatus(err.code === "rate_limited" && err.retryAfterSeconds !== undefined ? t("tryAgain", { n: err.retryAfterSeconds }) : t("searchFailed", { message: errText(err) }), "err");
     }).then(function () { i.searching = false; renderAll(); });
   }
-  // Opening the tab shows the newest round's words with their results: when the record has none, it asks once.
+  // A workspace with no search yet shows its newest round's words with their results: it asks once.
   function autoSearch() {
     var v = state.view;
     var i = state.insp;
-    if (!v || !v.runDir || i.searching || i.typed || !visible()) return;
-    var words = roundWords();
-    var q = words ? searchable(words.query) : "";
-    if (!q || findSearch(q)) return;
+    if (!v || !v.runDir || i.searching || !visible() || searchList().length > 0) return;
+    var q = searchable(roundWords());
+    if (!q) return;
     var key = v.runDir + "\n" + norm(q);
     if (i.auto[key]) return;
     i.auto[key] = true;
     runSearch(q);
   }
 `;
-export const SLATE_UI_INSPIRATION = `${SEARCH_AND_SELECTION}\n${SLATE_UI_INSPIRATION_COLLAGE}\n${SLATE_UI_INSPIRATION_GRID}`;
+export const SLATE_UI_INSPIRATION = `${SHELL_SEARCH_AND_SELECTION}\n${SLATE_UI_INSPIRATION_COLLAGE}\n${SLATE_UI_INSPIRATION_GALLERY}\n${SLATE_UI_INSPIRATION_GRID}`;
 //# sourceMappingURL=mcp-slate-ui-script-inspiration.js.map

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,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,8CAA8C,CAAC;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAEtF;;;;GAIG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,uBAAuB,CAAC;AAEtE;;;;GAIG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAG,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAA;;uBAEhB,IAAI,CAAC,SAAS,CAAC,8BAA8B,CAAC;sBAC/C,IAAI,CAAC,SAAS,CAAC,6BAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyOlE,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,oBAAoB,KAAK,4BAA4B,KAAK,yBAAyB,EAAE,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-inspiration.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inspiration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,8CAA8C,CAAC;AAC5F,OAAO,EAAE,4BAA4B,EAAE,MAAM,8CAA8C,CAAC;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAEtF;;;;GAIG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,uBAAuB,EAAW,CAAC;AAEtG,kHAAkH;AAClH,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAG,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,0BAA0B,GAAG,MAAM,CAAC,GAAG,CAAA;;6CAEA,IAAI,CAAC,SAAS,CAAC,8BAA8B,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,8BAA8B,CAAC,KAAK,CAAC;sBACtI,IAAI,CAAC,SAAS,CAAC,6BAA6B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8TlE,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,0BAA0B,KAAK,4BAA4B,KAAK,4BAA4B,KAAK,yBAAyB,EAAE,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-l10n.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-l10n.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,aAAa,QAmGzB,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAG,MAKjB,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-l10n.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-l10n.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,aAAa,QAqGzB,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAG,MAKjB,CAAC"}

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

@@ -94,6 +94,8 @@ export const SLATE_UI_L10N = String.raw `
     for (var i = 0; i < words.length; i++) words[i].textContent = t(words[i].getAttribute("data-l10n"));
     var named = root.querySelectorAll("[data-l10n-aria]");
     for (var j = 0; j < named.length; j++) named[j].setAttribute("aria-label", t(named[j].getAttribute("data-l10n-aria")));
+    var placeheld = root.querySelectorAll("[data-l10n-placeholder]");
+    for (var p = 0; p < placeheld.length; p++) placeheld[p].setAttribute("placeholder", t(placeheld[p].getAttribute("data-l10n-placeholder")));
     var labelled = root.querySelectorAll("[data-l10n-label]");
     for (var k = 0; k < labelled.length; k++) {
       var label = t(labelled[k].getAttribute("data-l10n-label"));

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

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-l10n.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-l10n.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmGtC,CAAC;AAEF,gFAAgF;AAChF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,QAAgD,EAAU,EAAE,CAAC,aAAa;KACxG,OAAO,CAAC,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;KACvD,OAAO,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;KACnD,OAAO,CAAC,gBAAgB,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;KACrD,OAAO,CAAC,gBAAgB,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;KACrD,OAAO,CAAC,kBAAkB,EAAE,GAAG,EAAE,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-l10n.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-l10n.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqGtC,CAAC;AAEF,gFAAgF;AAChF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,QAAgD,EAAU,EAAE,CAAC,aAAa;KACxG,OAAO,CAAC,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;KACvD,OAAO,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;KACnD,OAAO,CAAC,gBAAgB,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;KACrD,OAAO,CAAC,gBAAgB,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;KACrD,OAAO,CAAC,kBAAkB,EAAE,GAAG,EAAE,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC,CAAC"}

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

@@ -1,37 +1,8 @@
 /**
- * Generate more: a dashed tile with a plus and the words Generate more, and
- * the panel it opens directly below it. In the card it is the last tile of the
- * strip, whose thumbnails wrap rather than scroll sideways, and the panel
- * opens below the strip; in the workspace it is a slim bar on top of the
- * selection, before the newest round in the column's flow (rounds are newest
- * first, so it sits where the next round will land), and the panel opens under
- * the bar. Either way it is in view without a scroll from where the thumbnails
- * rest. The panel is the only way to start a round, and it says what it will
- * do:
- *
- * - 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, 6, 8 or 12, default 6) and Cancel and
- *   Generate.
- *
- * 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
- * the thread, so a panel added below the thumbnails lands under the host's
- * composer, out of sight (the frame's own document has nothing to scroll).
- * While the panel is open the image is shortened by the panel's height, and
- * folded away when what would be left is too small to read, so the card keeps
- * its height and the panel sits where the bottom of the card already was.
+ * How a new round starts. The Designs tab's More (with its 6 or 12, mcp-slate-ui-script-designs.ts) and the
+ * Inspiration tab's Generate both come here: the inspiration selection is committed first, so the round uses what the
+ * person sees, then the run is recorded and the returned view already carries the round's loading tiles. While a round
+ * runs, or the request is in flight, More and Branch are off.
  */
 export declare const SLATE_UI_MORE: string;
 //# sourceMappingURL=mcp-slate-ui-script-more.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,aAAa,QAqQzB,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-more.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-more.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAiBzB,CAAC"}