@12ui/design 0.2.80 → 0.2.82

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

@@ -0,0 +1,365 @@
+/**
+ * The Designs tab, the same in the card and in the workspace: every round as a section, newest first, with a slim bar
+ * (how many designs a round draws, 6 or 12, and More) at the right of the newest round's head. A section's head is small: the round's number, a strip of the
+ * inspiration and references that fed it (or, for a branch, the design it grew from), and a status dot. Under it a grid
+ * of large tiles in the frame's shape.
+ *
+ * A tile is one version of a design: its picture, its code (A, or A2 from A after an edit, or a branch's page name), a
+ * filled check and ring when it is the pick, and four icon actions: expand, edit, branch and choose. An edit's new
+ * version sits right after its source; while it draws, a loading tile already holds its place. A design still being
+ * drawn is a shimmer tile of the frame's shape that fills in the moment its picture lands.
+ *
+ * The card shows the newest round and folds the rest behind one button; the workspace shows every round. Clicking a
+ * tile, or its expand action, opens the large view (mcp-slate-ui-script-viewer.ts); edit and branch open it on their
+ * bar. Choose is Select (mcp-slate-ui-script-select.ts).
+ */
+export const SLATE_UI_DESIGNS = String.raw `
+  var ICON = {
+    expand: "M4 9V4h5M20 9V4h-5M4 15v5h5M20 15v5h-5",
+    collapse: "M9 4v5H4M15 4v5h5M9 20v-5H4M15 20v-5h5",
+    edit: "M12 20h9M16.5 3.5a2.1 2.1 0 0 1 3 3L7 19l-4 1 1-4z",
+    branch: "M6 3v12M6 21a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5zM18 8.5a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5zM18 8.5c0 5-6 4.5-12 8",
+    choose: "M20 6 9 17l-5-5",
+    plus: "M12 5v14M5 12h14",
+    minus: "M5 12h14",
+    close: "M6 6l12 12M18 6L6 18",
+    left: "M15 18l-6-6 6-6",
+    right: "M9 18l6-6-6-6",
+    fit: "M9 4H4v5M15 4h5v5M9 20H4v-5M15 20h5v-5",
+    send: "M5 12h14M13 6l6 6-6 6",
+    undo: "M9 14L4 9l5-5M4 9h10a6 6 0 0 1 0 12h-3",
+    convert: "M8 8l-5 4 5 4M16 8l5 4-5 4M13.5 5l-3 14",
+    resume: "M4 12a8 8 0 1 0 2.3-5.7M4 4v4h4"
+  };
+  function svgIcon(path, size) {
+    var s = size || 18;
+    return '<svg viewBox="0 0 24 24" width="' + s + '" height="' + s + '" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="' + path + '"/></svg>';
+  }
+  // An icon-only action: its words are its accessible name and its tooltip.
+  function iconAction(label, path, onclick, cls) {
+    var b = button("", "ia" + (cls ? " " + cls : ""), function (e) { if (e && e.stopPropagation) e.stopPropagation(); onclick(b); });
+    b.setAttribute("aria-label", label);
+    b.title = label;
+    b.innerHTML = svgIcon(path, 16);
+    return b;
+  }
+
+  // A labelled action of the large view: its icon and its word.
+  function wordAction(label, path, onclick, cls) {
+    var b = iconAction(label, path, onclick, "big wide" + (cls ? " " + cls : ""));
+    b.appendChild(el("span", "", label));
+    return b;
+  }
+
+  var designs = { perRound: 0, showAll: false, filling: false, error: "" };
+  // How many a round draws: what the newest round drew (6 unless it drew 12), until the person taps the other.
+  function perRound() {
+    if (designs.perRound) return designs.perRound;
+    var newest = newestRound(function (r) { return r.kind !== "branch"; });
+    return newest && newest.count >= 12 ? 12 : 6;
+  }
+  function roundsNewestFirst() { return state.view.rounds.slice().sort(function (a, b) { return b.index - a.index; }); }
+  function newestRound(test) { return roundsNewestFirst().filter(test || function () { return true; })[0] || null; }
+  function roundOfCandidate(c) { return roundById(c.roundId); }
+
+  // ---- the tiles of a round: every version of every design, an edit right after its source ----
+  // An edit that is running holds the place its version will take: the op names its parent, and its version is not in yet.
+  function pendingEdits(c) {
+    return state.view.ops.filter(function (op) {
+      if (op.kind !== "edit" || !isRunning(op) || !op.edit) return false;
+      if (c.versionIds.indexOf(op.edit.parentVersionId) < 0) return false;
+      return !op.resultVersionIds.some(function (id) { return c.versionIds.indexOf(id) >= 0; });
+    });
+  }
+  function roundItems(round) {
+    var items = [];
+    state.view.candidates.filter(function (c) { return c.roundId === round.roundId; }).sort(byLabel).forEach(function (c) {
+      var versions = versionsOf(c);
+      if (versions.length === 0) items.push({ c: c, v: null, op: null });
+      versions.forEach(function (v) { items.push({ c: c, v: v, op: null }); });
+      pendingEdits(c).forEach(function (op, i) { items.push({ c: c, v: null, op: op, n: versions.length + 1 + i }); });
+    });
+    return items;
+  }
+  // Every version on screen, in screen order: what the large view steps through.
+  function viewerOrder() {
+    var list = [];
+    roundsNewestFirst().forEach(function (r) { roundItems(r).forEach(function (it) { if (it.v && it.v.fileState === "ok") list.push(it.v); }); });
+    return list;
+  }
+
+  // The name a tile carries: its code; an edit says what it came from; a branch's page carries its page name.
+  function pageName(c) {
+    if (c.page) return c.page;
+    var round = roundOfCandidate(c);
+    if (!round || round.kind !== "branch") return "";
+    var own = state.view.candidates.filter(function (x) { return x.roundId === c.roundId; }).sort(byLabel);
+    return t("pageName", { n: own.indexOf(c) + 2 });
+  }
+  function tileName(c, v) {
+    var page = pageName(c);
+    if (v) return page ? t("versionPage", { label: v.label, page: page }) : t("versionName", { label: v.label });
+    return page ? t("versionPage", { label: c.label, page: page }) : optionName(c);
+  }
+  function parentLabel(v) {
+    var parent = v && v.kind === "edit" && v.parentVersionId ? ver(v.parentVersionId) : null;
+    return parent ? parent.label : "";
+  }
+
+  function tileOf(item) {
+    var c = item.c, v = item.v;
+    var tile = el("div", "dtile");
+    tile.style.setProperty("--ar", String(v && sized(v) ? v.width / v.height : ratioOf(c)));
+    tile.setAttribute("data-option", c.label);
+    if (v) tile.setAttribute("data-version", v.label);
+    var face = button("", "dface");
+    tile.appendChild(face);
+    var shown = !!v && v.fileState === "ok";
+    var waitingRef = !v && !item.op ? pausedRef(c) : null;
+    if (shown) {
+      var img = el("img", "thumb empty");
+      img.alt = "";
+      img.setAttribute("draggable", "false");
+      face.appendChild(img);
+      var cached = state.thumbs[imageKey(v, "thumb")];
+      if (cached) { img.src = cached; img.classList.remove("empty"); }
+      else bindImage(img, v, "thumb", false);
+      face.setAttribute("aria-label", t("expandName", { name: tileName(c, v) }));
+      face.addEventListener("click", function () { openViewer(v.versionId, null); });
+    } else if (item.op || drawing(c)) {
+      tile.classList.add("loading");
+      face.classList.add("shimmer");
+      face.appendChild(el("span", "spin"));
+      face.setAttribute("aria-label", t("drawingName", { name: item.op ? t("versionName", { label: c.label + item.n }) : tileName(c, null) }));
+      face.disabled = true;
+    } else if (waitingRef) {
+      tile.classList.add("paused");
+      var ref = el("img", "thumb empty");
+      ref.alt = "";
+      face.appendChild(ref);
+      bindReference(ref, waitingRef, "thumb");
+      face.title = t("pauseDrawsFrom", { label: c.label });
+      face.setAttribute("aria-label", t("pauseDrawsFrom", { label: c.label }));
+      face.disabled = true;
+    } else {
+      var note = v ? (v.fileState === "changed" ? t("fileChanged") : t("fileMissing")) : optionNote(c);
+      tile.classList.add(c.state === "failed" ? "failed" : "stopped");
+      face.title = note;
+      face.setAttribute("aria-label", tileName(c, v) + ". " + note);
+      var words = el("span", "tilenote");
+      words.appendChild(el("span", "", note));
+      face.appendChild(words);
+      face.disabled = true;
+    }
+
+    // The tag: code, then where it came from (an edit) or its page (a branch).
+    var tag = el("span", "dtag");
+    tag.appendChild(el("b", "code", item.op ? c.label + item.n : (v ? v.label : c.label)));
+    var from = item.op ? (ver(item.op.edit.parentVersionId) || {}).label : parentLabel(v);
+    if (from) tag.appendChild(el("span", "dfrom", t("fromLabel", { label: from })));
+    var page = pageName(c);
+    if (page) tag.appendChild(el("span", "dpage", page));
+    if (v && v.kind === "edit") tag.title = chipTitle(v);
+    else if (from) tag.title = t("fromLabel", { label: from });
+    var meta = el("div", "dmeta");
+    meta.appendChild(tag);
+    tile.appendChild(meta);
+
+    if (shown && samePick(v)) {
+      tile.classList.add("chosen");
+      var badge = el("span", "dchosen");
+      badge.innerHTML = svgIcon(ICON.choose, 15);
+      badge.appendChild(el("span", "sr", t("chosen")));
+      tile.appendChild(badge);
+    }
+    if (shown) tile.appendChild(choosePill(v));
+    return tile;
+  }
+  function chipTitle(v) {
+    if (v.promptFromMarks) return t("versionTitleMarks", { label: v.label });
+    return v.prompt ? t("versionTitle", { label: v.label, prompt: v.prompt }) : v.label;
+  }
+  // The tile's one action, shown on hover or keyboard focus (always on a touch screen): Choose, or Chosen for the pick.
+  function choosePill(v) {
+    var on = samePick(v);
+    var pill = button(on ? t("chosen") : t("choose"), "dpick" + (on ? " on" : ""), function () { doSelect(v); });
+    pill.setAttribute("aria-pressed", on ? "true" : "false");
+    pill.disabled = state.busy || !pickable(v);
+    return pill;
+  }
+
+  // ---- a round's head: its number, what fed it, and a status dot ----
+  function feedStrip(round) {
+    var strip = el("span", "feed");
+    strip.setAttribute("role", "img");
+    if (round.kind === "branch" || round.kind === "like") {
+      var src = ver(round.fromVersionId);
+      if (src) {
+        var mini = el("img", "feedimg design empty");
+        mini.alt = "";
+        strip.appendChild(mini);
+        bindImage(mini, src, "thumb", false);
+      }
+      strip.setAttribute("aria-label", round.kind === "branch" ? t("branchOf", { label: src ? src.label : "" }) : t("likeTitle", { label: src ? src.label : "" }));
+      if (round.kind === "branch") return strip;
+    }
+    var ids = round.referenceIds.slice(0, 8);
+    ids.forEach(function (id) {
+      var img = el("img", "feedimg empty");
+      img.alt = "";
+      img.title = refName(id);
+      strip.appendChild(img);
+      bindReference(img, id, "thumb");
+    });
+    if (round.referenceIds.length > ids.length) strip.appendChild(el("span", "feedmore", "+" + (round.referenceIds.length - ids.length)));
+    if (round.kind !== "like") strip.setAttribute("aria-label", t("fedBy"));
+    return strip;
+  }
+  function roundOp(round) {
+    return state.view.ops.filter(function (o) { return o.kind === "round" && roundOfOp(o) && roundOfOp(o).roundId === round.roundId; }).pop() || null;
+  }
+  function roundStatus(round) {
+    var op = roundOp(round);
+    var box = el("span", "dstat");
+    if (op && isRunning(op) && !pausedFor({ roundId: round.roundId, state: "pending" })) {
+      box.appendChild(el("span", "dot run"));
+      box.appendChild(el("span", "", t("readyOf", { n: round.readyCount, m: round.count })));
+      box.setAttribute("role", "status");
+      return box;
+    }
+    if (op && (op.state === "interrupted" || op.state === "failed") && round.readyCount < round.count) {
+      var said = op.error && op.error.message ? serverText(op.error.l10n, op.error.message) : t("interrupted");
+      box.appendChild(el("span", "dot err"));
+      box.title = said;
+      box.appendChild(el("span", "sr", said));
+      if (op.resumable) box.appendChild(iconAction(t("resume"), ICON.resume, function (b) { actResume(op, b); }));
+      return box;
+    }
+    return null;
+  }
+  function sectionOf(round) {
+    var section = el("section", "dsec" + (round.kind === "branch" ? " branch" : ""));
+    section.setAttribute("data-round", String(round.index));
+    var head = el("div", "dhead");
+    if (round.kind === "branch") {
+      var src = ver(round.fromVersionId);
+      var icon = el("span", "dbranchicon");
+      icon.innerHTML = svgIcon(ICON.branch, 14);
+      head.appendChild(icon);
+      head.appendChild(el("h2", "dtitle", t("branchOf", { label: src ? src.label : "" })));
+      head.appendChild(feedStrip(round));
+    } else {
+      head.appendChild(el("h2", "dtitle", t("roundHeading", { n: round.index })));
+      head.appendChild(feedStrip(round));
+      if (round.note) { var note = el("span", "dnote", round.note); note.title = round.note; head.appendChild(note); }
+    }
+    head.appendChild(el("span", "spacer"));
+    var status = roundStatus(round);
+    if (status) head.appendChild(status);
+    section.appendChild(head);
+    var grid = el("div", "dgrid");
+    var items = roundItems(round);
+    grid.style.setProperty("--shape", String(Math.round(Math.sqrt(items.length && items[0].v && sized(items[0].v) ? items[0].v.width / items[0].v.height : ratioOf(items[0] ? items[0].c : {})) * 1000) / 1000));
+    items.forEach(function (it) { grid.appendChild(tileOf(it)); });
+    section.appendChild(grid);
+    return section;
+  }
+
+  // ---- the bar: how many a round draws, and More ----
+  function designsBar() {
+    var bar = el("div", "dbar");
+    var seg = el("div", "seg count");
+    seg.setAttribute("role", "radiogroup");
+    seg.setAttribute("aria-label", t("perRound"));
+    [6, 12].forEach(function (n) {
+      var b = button(String(n), "segbtn");
+      b.setAttribute("role", "radio");
+      b.setAttribute("aria-checked", perRound() === n ? "true" : "false");
+      b.addEventListener("click", function () { setPerRound(n); });
+      seg.appendChild(b);
+    });
+    bar.appendChild(seg);
+    var more = button("", "primary morebtn", function () { drawMore(perRound()); });
+    more.innerHTML = svgIcon(ICON.plus, 16);
+    more.appendChild(el("span", "", t("more")));
+    more.disabled = moreBusy() || !localImage().ready;
+    if (!localImage().ready && localReason()) more.title = localReason();
+    bar.appendChild(more);
+    var alert = el("p", "alert");
+    alert.setAttribute("role", "alert");
+    alert.textContent = designs.error;
+    bar.appendChild(alert);
+    return bar;
+  }
+  // Tapping 12 draws a round of twelve at once (one tap, one round of 12, which then keeps the switch on 12); tapping
+  // 6 only sets the next rounds.
+  function setPerRound(n) {
+    if (perRound() === n && designs.perRound) return;
+    designs.perRound = n;
+    var newest = newestRound(function (r) { return r.kind !== "branch"; });
+    if (n === 12 && newest && newest.count < 12 && !moreBusy() && localImage().ready) {
+      drawMore(12);
+      return;
+    }
+    renderAll();
+  }
+  function drawMore(count) {
+    if (moreBusy() || !localImage().ready || designs.filling) return;
+    designs.filling = true;
+    designs.error = "";
+    renderAll();
+    startRound(uuid4(), { mode: "new", note: "", count: count }).then(function () {
+      designs.filling = false;
+      renderAll();
+    }, function (err) {
+      designs.filling = false;
+      designs.error = errText(err);
+      renderAll();
+    });
+  }
+
+  function designsSignature(where) {
+    var v = state.view;
+    return JSON.stringify([where, perRound(), designs.showAll, designs.error, moreBusy(), localImage().ready, state.busy, v.pick && [v.pick.versionId, v.pick.intact],
+      v.rounds.map(function (r) { return [r.roundId, r.kind, r.state, r.count, r.readyCount, r.referenceIds, r.fromVersionId, r.note, !!r.pause]; }),
+      v.candidates.map(function (c) { return [c.candidateId, c.state, c.error, c.versionIds, c.busy, c.page, drawing(c), pausedRef(c)]; }),
+      v.versions.map(function (x) { return [x.versionId, x.sha256, x.fileState, x.editable]; }),
+      v.ops.map(function (o) { return [o.opId, o.state, o.resumable, o.resultVersionIds]; })]);
+  }
+
+  // The tab in one host: the card ("card") or the workspace ("stage").
+  function renderDesigns(host, where) {
+    if (!state.view) return;
+    var focusKey = host.contains(document.activeElement) ? keyOf(document.activeElement) : null;
+    var rebuilt = setIfChanged(host, designsSignature(where), function (node) {
+      var bar = designsBar();
+      var rounds = roundsNewestFirst();
+      // The card: the newest round of new designs and any branch drawn since it; the rest fold behind one button.
+      var cut = rounds.findIndex(function (r) { return r.kind !== "branch"; });
+      var shown = where === "card" && !designs.showAll ? rounds.slice(0, cut < 0 ? rounds.length : cut + 1) : rounds;
+      // The bar sits at the right of the newest round's head, so it takes no row of its own.
+      shown.forEach(function (r, i) {
+        var section = sectionOf(r);
+        if (i === 0) section.querySelector(".dhead").appendChild(bar);
+        node.appendChild(section);
+      });
+      if (shown.length === 0) node.appendChild(bar);
+      if (shown.length < rounds.length) {
+        var earlier = button(t("showEarlier"), "textbtn earlier", function () { designs.showAll = true; renderAll(); });
+        node.appendChild(earlier);
+      }
+    });
+    if (rebuilt && focusKey) {
+      var back = Array.prototype.filter.call(host.querySelectorAll("button"), function (b) { return keyOf(b) === focusKey; })[0];
+      if (back) back.focus();
+    }
+  }
+  // A focusable control's place (its tile and its name), so a rebuild can put keyboard focus back on the same control.
+  function keyOf(node) {
+    if (!node || !node.closest) return null;
+    var tile = node.closest(".dtile");
+    var label = node.getAttribute("aria-label") || node.textContent || "";
+    return (tile ? tile.getAttribute("data-version") || tile.getAttribute("data-option") : "bar") + "|" + label;
+  }
+`;
+//# sourceMappingURL=mcp-slate-ui-script-designs.js.map

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * The pieces the large view's edit uses: the instruction counted as the servers count it, what this Mac can do now,
+ * the edit action with its marked picture, and the run call. Edit and Branch are bars of the large view
+ * (mcp-slate-ui-script-viewer.ts).
+ *
+ * Fragment of the view's script; String.raw, no backtick, no dollar-brace.
+ */
+export declare const SLATE_UI_EDIT: string;
+//# sourceMappingURL=mcp-slate-ui-script-edit.d.ts.map

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

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

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

@@ -0,0 +1,71 @@
+/**
+ * The pieces the large view's edit uses: the instruction counted as the servers count it, what this Mac can do now,
+ * the edit action with its marked picture, and the run call. Edit and Branch are bars of the large view
+ * (mcp-slate-ui-script-viewer.ts).
+ *
+ * Fragment of the view's script; String.raw, no backtick, no dollar-brace.
+ */
+export const SLATE_UI_EDIT = String.raw `
+  // ---- the edit instruction, counted as the servers count it: UTF-8 bytes of the words, control characters stripped ----
+  var EDIT_PROMPT_MAX_BYTES = __EDIT_PROMPT_MAX_BYTES__;
+  function editWords(text) { return String(text || "").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").trim(); }
+  function utf8Bytes(text) {
+    var n = 0;
+    for (var i = 0; i < text.length; i++) {
+      var c = text.charCodeAt(i);
+      if (c < 0x80) n += 1;
+      else if (c < 0x800) n += 2;
+      else if (c >= 0xd800 && c <= 0xdbff && i + 1 < text.length && text.charCodeAt(i + 1) >= 0xdc00 && text.charCodeAt(i + 1) <= 0xdfff) { n += 4; i++; }
+      else n += 3;
+    }
+    return n;
+  }
+  // How many characters must go from the end of the instruction for it to fit; 0 when it fits.
+  function editOverBy(text) {
+    var words = editWords(text);
+    var over = utf8Bytes(words) - EDIT_PROMPT_MAX_BYTES;
+    if (over <= 0) return 0;
+    var chars = Array.from(words);
+    var cut = 0;
+    while (over > 0 && chars.length > 0) { over -= utf8Bytes(chars.pop()); cut++; }
+    return cut;
+  }
+
+  // ---- what this Mac can do now ----
+  function localImage() { return (state.view && state.view.local && state.view.local.image) || { ready: false, reason: null }; }
+  // Why this Mac cannot draw, in the person's language when the server named it by code.
+  function localReason() { var local = localImage(); return serverText(local.reasonL10n, local.reason); }
+
+  // ---- the edit: words, marks or both ----
+  // 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 };
+    var words = editWords(d.prompt);
+    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;
+  }
+  // The hosted server takes the marked image from the screen (there is no server-side compositing), so an edit with
+  // strokes carries it; the local server draws its own from the strokes.
+  function editActionFor(d, version) {
+    var action = editAction(d);
+    if (TARGET !== "remote" || d.strokes.length === 0) return Promise.resolve(action);
+    return compositeMarked(version, d.strokes).then(function (marked) {
+      action.annotated = marked;
+      return action;
+    }, function (err) { throw new Error(t("markFailed", { detail: errText(err) })); });
+  }
+
+  // ---- send ----
+  function runAction(action, opId) {
+    return callTool(TOOLS.run, { runDir: state.view.runDir, opId: opId, action: action }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.view) applyView(sc.view, true);
+      // The hosted server draws nothing: the workspace runner on the person's Mac does, or else the person's agent,
+      // which is told here (best effort, like Select) only when no runner holds the workspace.
+      if (TARGET === "remote") remoteAfterRun(action, opId, sc.runner);
+      return sc;
+    });
+  }
+`;
+//# sourceMappingURL=mcp-slate-ui-script-edit.js.map

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

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

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

@@ -1,13 +1,7 @@
 /**
- * The inline card: one large image of the selected option with a badge,
- * Select under it, and the strip of thumbnails (the newest round, plus the
- * picked or viewed option of an older round) on as many rows as it takes,
- * ending with the Generate more tile; an icon-only control opens the
- * workspace. There is no status line: an option being drawn shimmers, one
- * that failed or stopped says why on its tile, and an error about a click
- * shows beside Select. Also the view application, the large image and the
- * thumbnail buttons shared with the workspace, and the tool-result entry
- * point.
+ * The inline card: the tabs and an icon-only control that opens the workspace, then the Designs tab
+ * (mcp-slate-ui-script-designs.ts) or Inspiration. An error about a click shows in one line under the tab. Also the
+ * view application, the render switch between card and workspace, and the tool-result entry point.
  */
 export declare const SLATE_UI_INLINE: string;
 //# sourceMappingURL=mcp-slate-ui-script-inline.d.ts.map

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;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,QAgQ3B,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-inline.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-inline.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAuI3B,CAAC"}