@12ui/design 0.2.71 → 0.2.73

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

@@ -0,0 +1,73 @@
+/**
+ * Select and the two hand-offs. Select acts at once: no dialog, and no reason
+ * (the pick tool takes none from here). It records the pick and then tells the
+ * agent, best effort. Branch and Convert (dialogs, in
+ * mcp-slate-ui-script-dialog.ts) end here: they record the request with the
+ * hand-off tool, under an id minted when the dialog opened, and then tell the
+ * agent to read it.
+ *
+ * What the agent is told names what happened and carries no command, no flag
+ * and no backtick: the host wraps app messages as untrusted input, so the
+ * agent confirms with the model-visible data tool. The user's own words (the
+ * Branch explanation) are never put in a message; the agent reads them from
+ * the record.
+ */
+export const SLATE_UI_SELECT = String.raw `
+  function samePick(version) {
+    var p = state.view && state.view.pick;
+    // A pick whose durable copy is gone is not a pick to rest on: Select stays available to record it again.
+    return !!p && p.intact !== false && !!version && p.versionId === version.versionId;
+  }
+
+  // What the agent is told, one wording per target: the local plugin's asks the agent to confirm through its tools, the
+  // hosted one is spec v2 9.2, and the browser's is only a record (its decision reaches the agent as the command's result).
+  function selectMessage(label, rev) {
+    if (TARGET === "remote") return remoteSelectMessage(label);
+    if (TARGET === "browser") return browserSelectMessage(label);
+    return "I selected " + label + " in the Design workspace (rev " + rev + "). " +
+      "Please confirm it with " + TOOLS.data + " for runDir " + state.view.runDir + ", and tell me its version id, path and sha256.";
+  }
+  function handoffMessage(kind, label, handoffId, rev) {
+    if (TARGET === "remote") return remoteHandoffMessage(kind, label, handoffId);
+    if (TARGET === "browser") return browserHandoffMessage(kind, label, handoffId);
+    return "I asked to " + (kind === "branch" ? "build from" : "convert") + " " + label + " in the Design workspace (rev " + rev + ", request " + handoffId + "). " +
+      "Please confirm it with " + TOOLS.data + " for runDir " + state.view.runDir + ", then carry it out and ask me before anything that uses my 12ui credits.";
+  }
+
+  function doSelect(version) {
+    // The button is disabled in these cases; the guard keeps a stray click (a script, a stale focus) from sending a second pick.
+    if (!version || state.busy || samePick(version) || !pickable(version)) return;
+    state.busy = true;
+    syncControls();
+    setStatus(COPY.recording);
+    callTool(TOOLS.pick, { runDir: state.view.runDir, versionId: version.versionId }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.view) applyView(sc.view, true);
+      var label = sc.pick ? sc.pick.label : version.label;
+      var rev = sc.rev !== undefined ? sc.rev : state.view.rev;
+      return messageAgent(selectMessage(label, rev)).then(function () {
+        setStatus(tpl(COPY.selectedLine, { label: label }), "ok");
+      }, function (err) {
+        setStatus(tpl(COPY.selectedRefused, { label: label, detail: errText(err) }), "err");
+      });
+    }, function (err) {
+      setStatus(tpl(COPY.couldNotSelect, { detail: errText(err) }), "err");
+    }).then(function () { state.busy = false; syncControls(); });
+  }
+
+  // Record a Branch or Convert request for the shown version, then tell the agent. Resolves once the agent has been
+  // told (or the host refused, which is shown but not thrown); rejects on a recording error so the dialog can show it.
+  function sendHandoff(kind, version, handoffId, options) {
+    return callTool(TOOLS.handoff, { runDir: state.view.runDir, handoffId: handoffId, kind: kind, versionId: version.versionId, options: options }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.view) applyView(sc.view, true);
+      var rev = sc.rev !== undefined ? sc.rev : state.view.rev;
+      return messageAgent(handoffMessage(kind, version.label, handoffId, rev)).then(function () {
+        setStatus(COPY.sent, "ok");
+      }, function (err) {
+        setStatus(tpl(COPY.sentRefused, { detail: errText(err) }), "err");
+      });
+    });
+  }
+`;
+//# sourceMappingURL=mcp-slate-ui-script-select.js.map

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * The fullscreen workspace: on the left the selection (compact thumbnails
+ * grouped by round, each option with its versions as chips), in the middle one
+ * large image, and under it one row of actions: Select, Design, Edit, Branch
+ * and Convert. Nothing else shows until a button is clicked; the dialogs live
+ * in mcp-slate-ui-script-dialog.ts. One band above the image says what is
+ * running, stopped or failed, with Resume when the work can resume. Mounted
+ * only in fullscreen.
+ */
+export declare const SLATE_UI_STAGE: string;
+//# sourceMappingURL=mcp-slate-ui-script-stage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-slate-ui-script-stage.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-stage.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,QA0K1B,CAAC"}

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

@@ -0,0 +1,181 @@
+/**
+ * The fullscreen workspace: on the left the selection (compact thumbnails
+ * grouped by round, each option with its versions as chips), in the middle one
+ * large image, and under it one row of actions: Select, Design, Edit, Branch
+ * and Convert. Nothing else shows until a button is clicked; the dialogs live
+ * in mcp-slate-ui-script-dialog.ts. One band above the image says what is
+ * running, stopped or failed, with Resume when the work can resume. Mounted
+ * only in fullscreen.
+ */
+export const SLATE_UI_STAGE = String.raw `
+  var stageBuilt = false;
+  var stageEls = {};
+
+  var ICON_CLOSE = "M6 6l12 12M18 6L6 18";
+  function iconButton(label, path, onclick) {
+    var b = button("", "iconbtn", onclick);
+    b.setAttribute("aria-label", label);
+    b.title = label;
+    b.innerHTML = '<svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="' + path + '"/></svg>';
+    return b;
+  }
+
+  function buildStageSkeleton() {
+    var stage = $("stage");
+    stage.textContent = "";
+    var head = el("header", "stagehead");
+    head.appendChild(el("h1", "sr", COPY.title));
+    head.appendChild(buildTabs());
+    head.appendChild(el("span", "spacer"));
+    stageEls.close = iconButton(COPY.closeWorkspace, ICON_CLOSE, closeWorkspace);
+    head.appendChild(stageEls.close);
+
+    stageEls.body = el("div", "stagebody");
+    stageEls.rail = el("nav", "rail");
+    stageEls.rail.setAttribute("aria-label", COPY.tabDesigns);
+    var main = el("section", "main");
+    stageEls.band = el("div", "band hidden");
+    stageEls.band.setAttribute("role", "status");
+    stageEls.hero = el("div", "hero");
+    var row = el("div", "actionrow");
+    stageEls.select = button(COPY.select, "primary", function () { doSelect(selectedVersion()); });
+    stageEls.design = button(COPY.design, "", function () { openDialog("design", stageEls.design); });
+    stageEls.edit = button(COPY.edit, "", function () { openDialog("edit", stageEls.edit); });
+    stageEls.branch = button(COPY.branch, "", function () { openDialog("branch", stageEls.branch); });
+    stageEls.convert = button(COPY.convert, "", function () { openDialog("convert", stageEls.convert); });
+    stageEls.editWhy = el("span", "sr");
+    stageEls.editWhy.id = "edit-why";
+    [stageEls.select, stageEls.design, stageEls.edit, stageEls.branch, stageEls.convert, stageEls.editWhy].forEach(function (b) { row.appendChild(b); });
+    stageEls.status = el("p", "status");
+    stageEls.status.setAttribute("data-status", "");
+    stageEls.status.setAttribute("role", "status");
+    stageEls.status.setAttribute("aria-live", "polite");
+    // A line set before the workspace was built (the first view arrives first) still shows.
+    stageEls.status.textContent = state.status.text;
+    if (state.status.kind) stageEls.status.className = "status " + state.status.kind;
+    main.appendChild(stageEls.band);
+    main.appendChild(stageEls.hero);
+    main.appendChild(row);
+    main.appendChild(stageEls.status);
+    stageEls.more = el("div", "morehost");
+    var selection = el("div", "selection");
+    selection.appendChild(stageEls.rail);
+    selection.appendChild(stageEls.more);
+    stageEls.body.appendChild(selection);
+    stageEls.body.appendChild(main);
+    stageEls.inspiration = el("div", "inspiration hidden");
+    stageEls.dialog = el("div", "dialogmount");
+
+    stage.appendChild(head);
+    stage.appendChild(stageEls.body);
+    stage.appendChild(stageEls.inspiration);
+    stage.appendChild(stageEls.dialog);
+    stageBuilt = true;
+  }
+
+  // A chip is one version of an option; its title carries the words of the edit that made it.
+  function chipTitle(v) { return v.prompt ? v.label + ": " + v.prompt : v.label; }
+
+  function buildRail(rail) {
+    var v = state.view;
+    v.rounds.slice().sort(function (a, b) { return b.index - a.index; }).forEach(function (round) {
+      var section = el("div", "round");
+      var head = el("h2", "roundhead", COPY.roundPrefix + round.index);
+      var title = roundTitle(round);
+      if (title) head.title = title;
+      section.appendChild(head);
+      var list = el("ul", "options");
+      orderedCandidates().filter(function (c) { return c.roundId === round.roundId; }).sort(byLabel).forEach(function (c) {
+        var item = el("li", "option");
+        item.appendChild(thumbCell(c, "opt"));
+        var versions = versionsOf(c);
+        if (versions.length > 1) {
+          var chips = el("div", "chips");
+          versions.forEach(function (version) {
+            var on = state.sel.versionId === version.versionId;
+            var chip = button(version.label, "chip" + (on ? " selected" : ""), function () { selectCandidate(c.candidateId, version.versionId); });
+            chip.title = chipTitle(version);
+            chip.setAttribute("aria-label", COPY.versionPrefix + version.label);
+            chip.setAttribute("aria-pressed", on ? "true" : "false");
+            chips.appendChild(chip);
+          });
+          item.appendChild(chips);
+        }
+        list.appendChild(item);
+      });
+      section.appendChild(list);
+      rail.appendChild(section);
+    });
+    var slot = el("div", "moreslot");
+    slot.appendChild(moreTile());
+    rail.appendChild(slot);
+  }
+
+  // ---- the band: what is running, stopped or failed ----
+  function buildBand(node, band) {
+    node.appendChild(el("span", "bandtext" + (band.kind === "failed" ? " err" : ""), band.text));
+    if (band.op.resumable) {
+      var b = button(COPY.resume, "textbtn", function () { actResume(band.op, b); });
+      node.appendChild(b);
+    }
+  }
+  function actResume(op, buttonEl) {
+    if (state.opBusy[op.opId]) return;
+    state.opBusy[op.opId] = true;
+    if (buttonEl) buttonEl.disabled = true;
+    callTool(TOOLS.resume, { runDir: state.view.runDir, opId: op.opId }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.view) applyView(sc.view, true);
+    }, function (err) { setStatus(errText(err), "err"); }).then(function () { state.opBusy[op.opId] = false; if (buttonEl) buttonEl.disabled = false; });
+  }
+
+  function syncStageControls(selectLabel, selectDisabled) {
+    if (!stageBuilt || !isFullscreen()) return;
+    var v = selectedVersion();
+    var any = !!state.view && state.view.candidates.length > 0;
+    if (selectLabel !== undefined) { stageEls.select.textContent = selectLabel; stageEls.select.disabled = selectDisabled; }
+    stageEls.design.disabled = !any;
+    // Edit is off when the shown version cannot be edited; the reason is its accessible description, not a tooltip.
+    var blocked = !v || !v.editable;
+    stageEls.edit.disabled = blocked;
+    stageEls.editWhy.textContent = blocked && v && v.editBlockedReason ? v.editBlockedReason : "";
+    if (blocked && v && v.editBlockedReason) stageEls.edit.setAttribute("aria-describedby", "edit-why"); else stageEls.edit.removeAttribute("aria-describedby");
+    stageEls.branch.disabled = !v;
+    stageEls.convert.disabled = !v;
+  }
+
+  // ---- render ----
+  function renderStage() {
+    var v = state.view;
+    if (!stageBuilt) buildStageSkeleton();
+    stageEls.close.classList.toggle("hidden", !canInline());
+    syncTabs();
+    syncProgressLine(v);
+    var onDesigns = state.tab === "designs";
+    stageEls.body.classList.toggle("hidden", !onDesigns);
+    stageEls.inspiration.classList.toggle("hidden", onDesigns);
+    if (!onDesigns) { renderInspiration(stageEls.inspiration, "stage"); return; }
+    var c = selectedCandidate();
+    var sel = selectedVersion();
+    if (v.candidates.length === 0) {
+      stageEls.rail.textContent = "";
+      stageEls.rail.__sig = "";
+      stageEls.band.classList.add("hidden");
+      stageEls.hero.__sig = "";
+      stageEls.hero.textContent = "";
+      stageEls.hero.classList.add("note");
+      stageEls.hero.appendChild(el("div", "heronote", COPY.empty));
+      syncStageControls(COPY.select, true);
+      return;
+    }
+    var railSig = JSON.stringify([state.sel, v.rounds.map(function (r) { return [r.roundId, r.index, r.kind, r.fromVersionId]; }),
+      orderedCandidates().map(function (x) { return thumbSignature(x).concat([x.versionIds]); })]);
+    setIfChanged(stageEls.rail, railSig, buildRail);
+    var band = activeBand(v);
+    stageEls.band.classList.toggle("hidden", !band);
+    setIfChanged(stageEls.band, band ? JSON.stringify([band.kind, band.text, band.op.opId, band.op.resumable]) : "", function (node) { if (band) buildBand(node, band); });
+    setIfChanged(stageEls.hero, heroSignature(c, sel), function (node) { heroInto(node, c, sel); });
+    syncControls();
+  }
+`;
+//# sourceMappingURL=mcp-slate-ui-script-stage.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-slate-ui-script-stage.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-stage.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0KvC,CAAC"}

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

@@ -0,0 +1,13 @@
+/**
+ * View state, the image loader queue and the status polling controller.
+ *
+ * Host limits, measured or derived (see the step-0 probe): about five
+ * concurrent app requests app-wide, so a view keeps at most three image loads
+ * in flight, version pictures and reference pictures together (leaving room
+ * for status and an action); it polls only while something is running and the
+ * document is visible, with backoff from two to ten seconds and a `since`
+ * stamp so an unchanged answer costs no re-render. A hidden view issues no
+ * calls at all.
+ */
+export declare const SLATE_UI_STATE: string;
+//# sourceMappingURL=mcp-slate-ui-script-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-slate-ui-script-state.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,QAqS1B,CAAC"}

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

@@ -0,0 +1,306 @@
+/**
+ * View state, the image loader queue and the status polling controller.
+ *
+ * Host limits, measured or derived (see the step-0 probe): about five
+ * concurrent app requests app-wide, so a view keeps at most three image loads
+ * in flight, version pictures and reference pictures together (leaving room
+ * for status and an action); it polls only while something is running and the
+ * document is visible, with backoff from two to ten seconds and a `since`
+ * stamp so an unchanged answer costs no re-render. A hidden view issues no
+ * calls at all.
+ */
+export const SLATE_UI_STATE = String.raw `
+  var state = {
+    host: {}, view: null,
+    sel: { candidateId: null, versionId: null, followLatest: true },
+    tab: "designs", query: "", dialog: null, more: null, wantEdit: null,
+    busy: false, status: { text: "", kind: "", source: "", phase: "" }, lastOpText: "", lastBandOp: "",
+    thumbs: {}, fulls: {}, refs: {}, lastOpStates: {}, opBusy: {}, awaitEdit: null,
+    insp: { local: null, writing: false, dirty: false, searching: false, waiters: [] }
+  };
+
+  // ---- small helpers ----
+  function el(tag, cls, text) {
+    var e = document.createElement(tag);
+    if (cls) e.className = cls;
+    if (text !== undefined) e.textContent = text;
+    return e;
+  }
+  function button(label, cls, onclick) {
+    var b = el("button", cls || "", label);
+    b.type = "button";
+    if (onclick) b.addEventListener("click", onclick);
+    return b;
+  }
+  function uuid4() {
+    var b = new Uint8Array(16);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) crypto.getRandomValues(b);
+    else for (var i = 0; i < 16; i++) b[i] = Math.floor(Math.random() * 256);
+    b[6] = (b[6] & 15) | 64;
+    b[8] = (b[8] & 63) | 128;
+    var h = Array.prototype.map.call(b, function (x) { return (x + 256).toString(16).slice(1); }).join("");
+    return h.slice(0, 8) + "-" + h.slice(8, 12) + "-" + h.slice(12, 16) + "-" + h.slice(16, 20) + "-" + h.slice(20);
+  }
+  function visible() { return document.visibilityState !== "hidden"; }
+  function errText(err) { return err && err.message ? err.message : String(err); }
+  // "source" is "op" for a line the screen derives from the ops' own state, "" for a message about a click.
+  function setStatus(text, kind, source, phase) {
+    state.status = { text: text || "", kind: kind || "", source: source || "", phase: phase || "" };
+    var nodes = document.querySelectorAll("[data-status]");
+    for (var i = 0; i < nodes.length; i++) {
+      nodes[i].textContent = state.status.text;
+      nodes[i].className = "status" + (kind ? " " + kind : "");
+    }
+  }
+
+  // ---- lookups over the current view ----
+  function cand(id) { return state.view && state.view.candidates.find(function (c) { return c.candidateId === id; }); }
+  function ver(id) { return state.view && state.view.versions.find(function (v) { return v.versionId === id; }); }
+  function latestVersion(c) { return c && c.latestVersionId ? ver(c.latestVersionId) : undefined; }
+  function roundById(id) { return state.view && state.view.rounds.find(function (r) { return r.roundId === id; }); }
+  function byLabel(a, b) { return a.label.length - b.label.length || (a.label < b.label ? -1 : a.label > b.label ? 1 : 0); }
+  // Newest round first, then by letter: the order of the strip and of the selection.
+  function optionOrder(a, b) {
+    var ra = roundById(a.roundId);
+    var rb = roundById(b.roundId);
+    return ((rb ? rb.index : 0) - (ra ? ra.index : 0)) || byLabel(a, b);
+  }
+  function orderedCandidates() { return state.view.candidates.slice().sort(optionOrder); }
+  // The card's strip: the newest round only, plus the option the pick belongs to and the one being viewed when they are
+  // older, so the large image always has its thumbnail. The workspace still lists every round.
+  function inlineCandidates() {
+    var all = orderedCandidates();
+    if (all.length === 0) return all;
+    var newest = all[0].roundId;
+    var picked = state.view.pick && ver(state.view.pick.versionId);
+    var keep = {};
+    keep[newest] = true;
+    if (picked) keep[picked.candidateId] = true;
+    if (state.sel.candidateId) keep[state.sel.candidateId] = true;
+    return all.filter(function (c) { return c.roundId === newest || keep[c.candidateId]; });
+  }
+  function versionsOf(c) { return c.versionIds.map(ver).filter(Boolean); }
+  function runningOps() { return state.view.ops.filter(function (o) { return o.state === "starting" || o.state === "running"; }); }
+  function selectedCandidate() { return cand(state.sel.candidateId); }
+  function selectedVersion() { return ver(state.sel.versionId); }
+  function optionName(c) { return COPY.optionPrefix + c.label + (c.state === "failed" ? COPY.failedSuffix : ""); }
+
+  function ensureSelection() {
+    var v = state.view;
+    if (!v || v.candidates.length === 0) { state.sel = { candidateId: null, versionId: null, followLatest: true }; return; }
+    var c = cand(state.sel.candidateId);
+    if (!c) {
+      var picked = v.pick && ver(v.pick.versionId);
+      var ordered = orderedCandidates();
+      c = (picked && cand(picked.candidateId)) || ordered.find(function (x) { return x.state === "ready"; }) || ordered[0];
+      state.sel = { candidateId: c.candidateId, versionId: null, followLatest: true };
+    }
+    var current = state.sel.versionId && c.versionIds.indexOf(state.sel.versionId) >= 0 ? state.sel.versionId : null;
+    if (state.sel.followLatest || !current) { state.sel.versionId = c.latestVersionId; state.sel.followLatest = true; }
+  }
+  // Choosing the option that is already shown, at the version already shown, changes nothing.
+  function selectCandidate(id, versionId) {
+    var c = cand(id);
+    if (!c) return;
+    var target = versionId || c.latestVersionId;
+    if (state.sel.candidateId === id && state.sel.versionId === target) return;
+    state.awaitEdit = null;
+    state.sel.candidateId = id;
+    state.sel.versionId = target;
+    state.sel.followLatest = !versionId || versionId === c.latestVersionId;
+    renderAll();
+  }
+
+  // ---- pictures through the app-only tools, at most three at a time; the workspace jumps the queue ----
+  var loader = { queue: [], active: 0, max: 3, inflight: {} };
+  function imageKey(version, size) { return size + ":" + version.versionId + ":" + version.sha256; }
+  function enqueue(key, cache, tool, args, urgent) {
+    if (cache[key]) return Promise.resolve(cache[key]);
+    if (loader.inflight[key]) {
+      if (urgent) {
+        var at = loader.queue.findIndex(function (j) { return j.key === key; });
+        if (at > 0) loader.queue.unshift(loader.queue.splice(at, 1)[0]);
+      }
+      return loader.inflight[key].promise;
+    }
+    var job = { key: key, cache: cache, tool: tool, args: args };
+    job.promise = new Promise(function (resolve, reject) { job.resolve = resolve; job.reject = reject; });
+    loader.inflight[key] = job;
+    if (urgent) loader.queue.unshift(job); else loader.queue.push(job);
+    pump();
+    return job.promise;
+  }
+  function wantImage(version, size, urgent) {
+    var cache = size === "full" ? state.fulls : state.thumbs;
+    return enqueue(imageKey(version, size), cache, TOOLS.image, { runDir: state.view.runDir, versionId: version.versionId, size: size }, urgent);
+  }
+  function wantReference(id, size, urgent) {
+    return enqueue("ref:" + size + ":" + id, state.refs, TOOLS.reference, { runDir: state.view.runDir, referenceId: id, size: size }, urgent);
+  }
+  function pump() {
+    while (visible() && loader.active < loader.max && loader.queue.length > 0) {
+      var job = loader.queue.shift();
+      loader.active++;
+      run(job);
+    }
+  }
+  function run(job) {
+    callTool(job.tool, job.args).then(function (result) {
+      var block = (result.content || []).find(function (b) { return b.type === "image"; });
+      if (!block) throw new Error("no image block returned");
+      var src = "data:" + block.mimeType + ";base64," + block.data;
+      job.cache[job.key] = src;
+      job.resolve(src);
+    }).catch(function (err) { job.reject(err); }).then(function () {
+      delete loader.inflight[job.key];
+      loader.active--;
+      pump();
+    });
+  }
+  function fillImage(img, promise) {
+    promise.then(function (src) {
+      if (img.isConnected === false) return;
+      img.src = src;
+      img.classList.remove("empty");
+    }, function (err) {
+      // An error is shown in place of the picture, never thrown.
+      img.alt = errText(err);
+      img.setAttribute("data-error", errText(err));
+    });
+  }
+  function bindImage(img, version, size, urgent) { if (version) fillImage(img, wantImage(version, size, urgent)); }
+  function bindReference(img, id, size) { fillImage(img, wantReference(id, size, false)); }
+
+  // ---- status polling ----
+  var DELAYS = [2000, 3000, 5000, 8000, 10000];
+  var poll = { timer: null, step: 0, inFlight: false };
+  function wantsPolling() { return !!state.view && !!state.view.runDir && visible() && runningOps().length > 0; }
+  function clearPoll() { if (poll.timer !== null) { clearTimeout(poll.timer); poll.timer = null; } }
+  function schedulePoll() {
+    clearPoll();
+    if (!wantsPolling() || poll.inFlight) return;
+    poll.timer = setTimeout(runPoll, DELAYS[Math.min(poll.step, DELAYS.length - 1)]);
+  }
+  function runPoll() {
+    poll.timer = null;
+    if (!wantsPolling()) return;
+    poll.inFlight = true;
+    callTool(TOOLS.status, { runDir: state.view.runDir, since: state.view.stamp }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.unchanged) poll.step++;
+      else if (sc.schema) { poll.step = 0; applyView(sc, true); }
+    }).catch(function () { poll.step++; }).then(function () { poll.inFlight = false; schedulePoll(); });
+  }
+  // One refresh when the view becomes visible again.
+  function refreshOnce() {
+    if (!state.view || !state.view.runDir || poll.inFlight) return;
+    poll.inFlight = true;
+    callTool(TOOLS.status, { runDir: state.view.runDir, since: state.view.stamp }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.schema) applyView(sc, true);
+    }).catch(function () {}).then(function () { poll.inFlight = false; schedulePoll(); });
+  }
+  document.addEventListener("visibilitychange", function () {
+    if (visible()) { pump(); refreshOnce(); schedulePoll(); }
+    else clearPoll();
+  });
+
+  // ---- what the ops say: the band of the workspace, the status line of the card ----
+  function opLabel(op) {
+    var parent = op.edit && ver(op.edit.parentVersionId);
+    var c = parent && cand(parent.candidateId);
+    return c ? c.label : (op.target || "");
+  }
+  function roundOfOp(op) {
+    var rounds = state.view.rounds;
+    var named = rounds.filter(function (r) { return COPY.roundPrefix + r.index === op.target; })[0];
+    if (named) return named;
+    var running = rounds.filter(function (r) { return r.state === "running"; });
+    return running.length ? running[running.length - 1] : null;
+  }
+  function progressText(op) {
+    // The hosted server has no runner of its own: a running op is waiting for the person's agent to draw and upload.
+    if (TARGET === "remote" && op.phase === "agent") return COPY.waitingForAgent;
+    if (op.kind === "round") {
+      var r = roundOfOp(op);
+      return r ? tpl(COPY.designingProgress, { n: r.readyCount, m: r.count }) : COPY.designing;
+    }
+    return tpl(COPY.editing, { label: opLabel(op) });
+  }
+  // The newest op. The local plugin stamps every op with a time; the hosted server sends none (data minimization), so
+  // its ops are already oldest first and the last one is the newest.
+  function latestOp(view) {
+    if (TARGET === "remote") return view.ops[view.ops.length - 1];
+    return view.ops.slice().sort(function (a, b) { return Date.parse(a.startedAt) - Date.parse(b.startedAt); }).pop();
+  }
+  // The one thing worth a band: work that is running, else work that stopped or failed as the newest word.
+  function activeBand(view) {
+    var running = view.ops.filter(function (o) { return o.state === "starting" || o.state === "running"; });
+    if (running.length) { var op = running[running.length - 1]; return { kind: "run", op: op, text: progressText(op) }; }
+    var last = latestOp(view);
+    if (last && last.state === "interrupted") return { kind: "stopped", op: last, text: TARGET === "remote" && last.error && last.error.message ? last.error.message : COPY.interrupted };
+    if (last && last.state === "failed" && last.error) return { kind: "failed", op: last, text: last.error.message };
+    return null;
+  }
+
+  // The card has one status line, so it also carries the running, stopped and failed words; the workspace has a band.
+  function syncProgressLine(view) {
+    var band = activeBand(view);
+    // The workspace's band speaks for running work, so a line about an earlier click ("Selected E.") is stale the
+    // moment a new op starts; a refusal stays, because the person has not read it away.
+    var bandOp = band && band.kind === "run" ? band.op.opId : "";
+    if (bandOp && bandOp !== state.lastBandOp && isFullscreen() && state.status.kind !== "err") setStatus("", "");
+    state.lastBandOp = bandOp;
+    if (isFullscreen() || !band) {
+      state.lastOpText = "";
+      if (state.status.source === "op" && state.status.phase === "progress") setStatus("", "");
+      return;
+    }
+    // A message about a click stays until these words themselves change.
+    if (band.text !== state.lastOpText) { state.lastOpText = band.text; setStatus(band.text, band.kind === "failed" ? "err" : "", "op", "progress"); }
+  }
+  // What a finished op produced. A failure is the band's to say in the workspace.
+  function syncDoneLine(prev, view) {
+    var was = {};
+    if (prev) prev.ops.forEach(function (o) { was[o.opId] = o.state; });
+    var finished = view.ops.filter(function (o) {
+      return (was[o.opId] === "starting" || was[o.opId] === "running") && (o.state === "succeeded" || o.state === "failed");
+    }).pop();
+    if (!finished) return;
+    if (finished.state === "failed") return;
+    var made = view.versions.filter(function (v) { return finished.resultVersionIds.indexOf(v.versionId) >= 0; });
+    if (finished.kind === "round") {
+      var n = made.length;
+      if (n === 0) return;
+      var round = roundOfOp(finished);
+      var failedCount = round ? view.candidates.filter(function (c) { return c.roundId === round.roundId && c.state === "failed"; }).length : 0;
+      var text = (n === 1 ? COPY.roundReadyOne : tpl(COPY.roundReadyMany, { n: n })) + (failedCount ? " " + tpl(COPY.roundFailed, { n: failedCount }) : "");
+      setStatus(text, failedCount ? "" : "ok", "op", "done");
+    } else {
+      setStatus(tpl(COPY.editReady, { label: made.length ? made[made.length - 1].label : opLabel(finished) }), "ok", "op", "done");
+    }
+  }
+  function syncOpStatus(prev, view) { syncProgressLine(view); syncDoneLine(prev, view); }
+
+  // ---- tell the agent, best effort, when work that was running has finished ----
+  function announceSettled(prev, next) {
+    next.ops.forEach(function (op) {
+      var was = state.lastOpStates[op.opId];
+      state.lastOpStates[op.opId] = op.state;
+      if (was !== "starting" && was !== "running") return;
+      if (op.state !== "succeeded" && op.state !== "failed") return;
+      var head = TARGET === "remote" ? "Design workspace: " : "Design workspace rev " + next.rev + ": ";
+      var text;
+      if (op.state === "failed") text = head + "the " + op.kind + " " + (op.target ? "for " + op.target + " " : "") + "failed" + (op.error ? " (" + op.error.code + ")" : "") + ".";
+      else if (op.kind === "round") {
+        var labels = next.candidates.filter(function (c) { return c.versionIds.some(function (id) { return op.resultVersionIds.indexOf(id) >= 0; }); }).map(function (c) { return c.label; });
+        text = head + (op.target || "the round") + " is ready" + (labels.length ? " (" + labels[0] + " to " + labels[labels.length - 1] + ")" : "") + ".";
+      } else {
+        var made = next.versions.find(function (v) { return op.resultVersionIds.indexOf(v.versionId) >= 0; });
+        text = head + (made ? made.label : opLabel(op)) + " was created.";
+      }
+      updateModelContext(text + " Confirm with " + TOOLS.data + ".");
+    });
+  }
+`;
+//# sourceMappingURL=mcp-slate-ui-script-state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-slate-ui-script-state.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqSvC,CAAC"}

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

@@ -0,0 +1,23 @@
+/**
+ * The two small controls on a design's thumbnail, in the card's strip and in
+ * the workspace's selection: a plus (More like this) and an edit pencil
+ * (Edit). They are siblings of the thumbnail button inside one cell (a button
+ * cannot hold buttons), revealed by CSS on hover and on keyboard focus within
+ * the cell, and on a device with no hover only on the selected thumbnail. A
+ * click on either never reaches the thumbnail, so it never swaps the large
+ * image by itself.
+ *
+ * The plus opens the Generate more panel for variations of that design
+ * (openMoreLike, in mcp-slate-ui-script-more.ts). Edit selects that design and
+ * opens the Edit dialog. The dialog lives in the workspace; the card has no
+ * room for the drawing surface, so in the card Edit opens the workspace and the
+ * dialog opens as soon as it shows (wantEdit). A host that cannot show the
+ * workspace has no place for the dialog, so there Edit is hidden in the card.
+ *
+ * Not on the Generate more tile, and not on an option that has no picture yet.
+ * Whether each control is on follows the view (syncThumbTools): the plus is off
+ * while a round runs (the tile's rule), Edit while that design has an edit in
+ * flight or its version cannot be edited.
+ */
+export declare const SLATE_UI_THUMBTOOLS: string;
+//# sourceMappingURL=mcp-slate-ui-script-thumbtools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-slate-ui-script-thumbtools.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-thumbtools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mBAAmB,QAgF/B,CAAC"}