@12ui/design 0.2.71 → 0.2.73

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

@@ -0,0 +1,221 @@
+/**
+ * The inline card: one large image of the selected option with a badge, one
+ * row under it with the strip of thumbnails (the newest round, plus the picked
+ * or viewed option of an older round) and Select, and one status line;
+ * an icon-only control opens the workspace. Also the view application, the
+ * large image and the thumbnail buttons shared with the workspace, and the
+ * tool-result entry point.
+ */
+export const SLATE_UI_INLINE = String.raw `
+  // ---- apply a view: selection, announcements, polling, render ----
+  var pickRestored = null;
+  function applyView(view, fromPoll) {
+    if (!view || view.schema !== "12ui.slate.view/3" || !Array.isArray(view.candidates)) return;
+    var prev = state.view;
+    if (prev && prev.runDir !== view.runDir) {
+      state.sel = { candidateId: null, versionId: null, followLatest: true };
+      state.dialog = null;
+      state.wantEdit = null;
+      resetMore();
+      state.insp.local = null;
+      state.awaitEdit = null;
+      pickRestored = null;
+    }
+    if (prev) announceSettled(prev, view);
+    else view.ops.forEach(function (op) { state.lastOpStates[op.opId] = op.state; });
+    if (!prev || prev.stamp !== view.stamp) poll.step = 0;
+    state.view = view;
+    // An edit that was just applied is shown the moment its version exists.
+    if (state.awaitEdit) {
+      var edited = cand(state.awaitEdit.candidateId);
+      if (edited && edited.versionIds.length > state.awaitEdit.count) {
+        state.sel = { candidateId: edited.candidateId, versionId: edited.latestVersionId, followLatest: true };
+        state.awaitEdit = null;
+      }
+    }
+    syncOpStatus(prev, view);
+    if (view.pick && pickRestored !== view.runDir) {
+      pickRestored = view.runDir;
+      var earlier = ver(view.pick.versionId);
+      if (earlier) state.sel = { candidateId: earlier.candidateId, versionId: earlier.versionId, followLatest: false };
+      if (!fromPoll && view.pick.fileState === "missing") setStatus(COPY.pickMissing, "err");
+      else if (!fromPoll && view.pick.fileState === "changed") setStatus(COPY.pickChanged, "err");
+    }
+    ensureSelection();
+    renderAll();
+    schedulePoll();
+  }
+
+  function renderAll() {
+    if (!state.view) return;
+    $("fatal").classList.add("hidden");
+    var full = isFullscreen();
+    $("app").classList.toggle("hidden", full);
+    $("stage").classList.toggle("hidden", !full);
+    if (full) renderStage(); else renderInline();
+    // Edit asked for from a thumbnail in the card: the workspace is showing now, so its dialog opens.
+    if (full) openWantedEdit();
+    // A dialog that is open follows the view: what this Mac can do now, for one.
+    if (state.dialog) updateDialogUi();
+    syncMore();
+    reportSize();
+  }
+
+  // Rebuild a container only when what it shows changed, so polling never steals focus or discards typing.
+  function setIfChanged(node, signature, build) {
+    if (node.__sig === signature) return false;
+    node.__sig = signature;
+    node.textContent = "";
+    build(node);
+    return true;
+  }
+
+  // ---- the large image, shared by the card and the workspace ----
+  function pickable(version) { return !!version && version.fileState === "ok"; }
+  // Why an option has no picture to show, or "" when it has one.
+  function optionNote(c) {
+    var v = latestVersion(c);
+    if (c.state === "failed") return c.error || optionName(c);
+    if (c.state === "pending") return optionName(c);
+    if (v && v.fileState === "missing") return COPY.fileMissing;
+    if (v && v.fileState === "changed") return COPY.fileChanged;
+    return "";
+  }
+  // The full picture jumps the queue; while it loads, the thumbnail (already fetched) stands in.
+  function heroInto(wrap, c, v) {
+    wrap.textContent = "";
+    wrap.classList.remove("note");
+    wrap.style.removeProperty("--ar");
+    if (!c) return;
+    if (!v || v.fileState !== "ok") {
+      wrap.classList.add("note");
+      var reason = !v ? optionNote(c) : v.fileState === "changed" ? COPY.fileChanged : COPY.fileMissing;
+      wrap.appendChild(el("div", "heronote" + (c.state === "pending" ? " shimmer" : ""), reason));
+      return;
+    }
+    wrap.style.setProperty("--ar", String(v.width / v.height));
+    var img = el("img", "heroimg empty");
+    img.alt = COPY.versionPrefix + v.label;
+    img.setAttribute("draggable", "false");
+    wrap.appendChild(img);
+    bindImage(img, v, "full", true);
+    var cached = state.thumbs[imageKey(v, "thumb")];
+    if (cached) img.src = cached;
+    wrap.appendChild(el("span", "badge", v.label));
+    if (c.busy) wrap.appendChild(progressBar());
+  }
+  function heroSignature(c, v) {
+    return JSON.stringify([state.sel, v && [v.sha256, v.fileState, v.label], c && [c.state, c.error, c.busy]]);
+  }
+
+  // ---- a small thumbnail button for an option: the strip in the card, the selection in the workspace ----
+  function thumbButton(c, cls) {
+    var b = button("", cls);
+    var selected = state.sel.candidateId === c.candidateId;
+    b.setAttribute("aria-label", optionName(c));
+    b.setAttribute("aria-pressed", selected ? "true" : "false");
+    if (selected) b.classList.add("selected");
+    b.setAttribute("data-option", c.label);
+    var v = latestVersion(c);
+    var note = optionNote(c);
+    if (note && c.state !== "pending") b.title = note;
+    if (c.state === "failed" || (v && v.fileState !== "ok")) b.classList.add("failed");
+    if (c.state === "pending") b.classList.add("shimmer");
+    var img = el("img", "thumb empty");
+    img.alt = "";
+    if (v && v.fileState === "ok" && c.state === "ready") bindImage(img, v, "thumb", false);
+    else img.setAttribute("data-nofile", "");
+    b.appendChild(img);
+    b.appendChild(el("b", "code", c.label));
+    b.addEventListener("click", function () { selectCandidate(c.candidateId); });
+    return b;
+  }
+  function thumbSignature(c) {
+    var lv = latestVersion(c);
+    return [c.candidateId, c.state, c.error, c.latestVersionId, c.versionIds.length, lv ? lv.fileState : ""];
+  }
+
+  function renderInline() {
+    var v = state.view;
+    var empty = v.candidates.length === 0;
+    $("empty").classList.toggle("hidden", !empty);
+    $("empty").textContent = COPY.empty;
+    $("card").classList.toggle("hidden", empty);
+    if (empty) { reportSize(); return; }
+    syncTabs();
+    var onDesigns = state.tab === "designs";
+    $("pane-designs").classList.toggle("hidden", !onDesigns);
+    $("pane-inspiration").classList.toggle("hidden", onDesigns);
+    if (!onDesigns) {
+      renderInspiration($("pane-inspiration"), "card");
+      syncControls();
+      reportSize();
+      return;
+    }
+    syncProgressLine(v);
+    var c = selectedCandidate();
+    var sel = selectedVersion();
+    setIfChanged($("hero"), heroSignature(c, sel), function (node) { heroInto(node, c, sel); });
+    var strip = $("strip");
+    // Where keyboard focus sits among the strip's buttons (a thumbnail, its two controls, the tile), so a rebuild can put it back.
+    var focusAt = strip.contains(document.activeElement) ? Array.prototype.indexOf.call(strip.querySelectorAll("button"), document.activeElement) : -1;
+    var options = inlineCandidates();
+    var rebuilt = setIfChanged(strip, JSON.stringify([state.sel.candidateId, options.map(thumbSignature)]), function (node) {
+      options.forEach(function (x) { node.appendChild(thumbCell(x, "thumbbtn")); });
+      node.appendChild(moreTile());
+    });
+    // Choosing a thumbnail rebuilds the strip: keep keyboard focus at the same place in it.
+    var stripButtons = strip.querySelectorAll("button");
+    if (rebuilt && focusAt >= 0 && stripButtons[focusAt]) stripButtons[focusAt].focus();
+    var shown = Array.prototype.filter.call(strip.children, function (b) { return b.classList.contains("selected"); })[0];
+    if (rebuilt && shown && shown.scrollIntoView && strip.scrollWidth > strip.clientWidth) { try { shown.scrollIntoView({ inline: "nearest", block: "nearest" }); } catch (e) { /* best effort */ } }
+    strip.classList.toggle("fade", strip.scrollWidth > strip.clientWidth + 1);
+    syncControls();
+    reportSize();
+  }
+  window.addEventListener("resize", function () {
+    var strip = $("strip");
+    if (strip) strip.classList.toggle("fade", strip.scrollWidth > strip.clientWidth + 1);
+  });
+
+  function syncControls() {
+    if (!state.view) return;
+    var v = selectedVersion();
+    var same = samePick(v);
+    var label = same ? COPY.selected : COPY.select;
+    var disabled = !(pickable(v) && !state.busy && !same);
+    if (!isFullscreen()) {
+      var expand = $("expand");
+      expand.classList.toggle("hidden", !canFullscreen());
+      expand.disabled = state.view.candidates.length === 0;
+      $("select").disabled = disabled;
+      $("select").textContent = label;
+    }
+    if (typeof syncStageControls === "function") syncStageControls(label, disabled);
+  }
+
+  function expandWorkspace() {
+    if (!canFullscreen()) return;
+    requestMode("fullscreen");
+  }
+  function closeWorkspace() {
+    if (isFullscreen() && canInline()) requestMode("inline");
+  }
+
+  $("expand").addEventListener("click", expandWorkspace);
+  $("select").addEventListener("click", function () { doSelect(selectedVersion()); });
+
+  // ---- tool result: the workspace ----
+  function onToolResult(result) {
+    if (!result || result.isError) {
+      var t = result && result.content && result.content[0] && result.content[0].text;
+      fatal(COPY.toolError + (t ? ": " + t : "."));
+      return;
+    }
+    var data = result.structuredContent;
+    if (!data || !Array.isArray(data.candidates)) { fatal(COPY.noView); return; }
+    applyView(data, false);
+  }
+
+`;
+//# sourceMappingURL=mcp-slate-ui-script-inline.js.map

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * The tabs (Designs and Inspiration, in the card and the workspace) and the
+ * Inspiration tab, which is the same in both places: a search row, the newest
+ * search's results, and one section per round with the references that
+ * produced its options. Every reference is a toggle. The selection lives in
+ * the view (`inspiration.selected`, at most eight, in click order) and is
+ * written whole through the inspiration tool, one write in flight at a time,
+ * last click wins locally; the next Design round reads it at commit. Nothing
+ * in this tab starts work.
+ */
+export declare const SLATE_UI_INSPIRATION: string;
+//# sourceMappingURL=mcp-slate-ui-script-inspiration.d.ts.map

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

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

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

@@ -0,0 +1,216 @@
+/**
+ * The tabs (Designs and Inspiration, in the card and the workspace) and the
+ * Inspiration tab, which is the same in both places: a search row, the newest
+ * search's results, and one section per round with the references that
+ * produced its options. Every reference is a toggle. The selection lives in
+ * the view (`inspiration.selected`, at most eight, in click order) and is
+ * written whole through the inspiration tool, one write in flight at a time,
+ * last click wins locally; the next Design round reads it at commit. Nothing
+ * in this tab starts work.
+ */
+export const SLATE_UI_INSPIRATION = String.raw `
+  var MAX_SELECTED = 8;
+
+  // 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", COPY.title);
+    [["designs", COPY.tabDesigns], ["inspiration", COPY.tabInspiration]].forEach(function (t) {
+      var b = button(t[1], "tab");
+      b.setAttribute("role", "tab");
+      b.setAttribute("data-tab", t[0]);
+      b.setAttribute("aria-selected", state.tab === t[0] ? "true" : "false");
+      bindTab(b);
+      tabs.appendChild(b);
+    });
+    return tabs;
+  }
+  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");
+  }
+  function setTab(tab) {
+    if ((tab !== "designs" && tab !== "inspiration") || state.tab === tab) return;
+    state.tab = tab;
+    syncTabs();
+    if (state.view) renderAll();
+  }
+  function bindTab(b) { b.addEventListener("click", function () { 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 : []);
+  }
+  function refMeta(id) { return (state.view.references && state.view.references[id]) || null; }
+  function refName(id) {
+    var m = refMeta(id);
+    return COPY.referencePrefix + String((m && m.description) || id).slice(0, 40);
+  }
+  function newestSearch() {
+    var searches = (state.view.inspiration && state.view.inspiration.searches) || [];
+    var best = null;
+    // The hosted server sends no time, only the order: the last search is the newest.
+    if (TARGET === "remote") return searches.length ? searches[searches.length - 1] : null;
+    searches.forEach(function (s) { if (!best || Date.parse(s.at) >= Date.parse(best.at)) best = s; });
+    return best;
+  }
+  function roundTitle(round) {
+    if (round.kind === "new") return COPY.newOptionsTitle;
+    if (round.kind === "like") { var from = ver(round.fromVersionId); return COPY.likePrefix + (from ? from.label : ""); }
+    return "";
+  }
+
+  // ---- the status line of this tab ----
+  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 : ""); }
+    state.inspMsg = { text: text || "", kind: kind || "" };
+  }
+
+  // ---- selection: optimistic, serialized, last write wins ----
+  function toggleRef(id) {
+    var cur = currentSelected().slice();
+    var at = cur.indexOf(id);
+    if (at >= 0) cur.splice(at, 1);
+    else {
+      if (cur.length >= MAX_SELECTED) { setInspStatus(COPY.eightAtMost, ""); return; }
+      cur.push(id);
+    }
+    setInspStatus("", "");
+    state.insp.local = cur;
+    renderAll();
+    writeSelection();
+  }
+  function writeSelection() {
+    var i = state.insp;
+    if (i.writing) { i.dirty = true; return; }
+    i.writing = true;
+    i.dirty = false;
+    callTool(TOOLS.inspiration, { runDir: state.view.runDir, referenceIds: i.local.slice() }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (!i.dirty) i.local = null;
+      if (sc.view) applyView(sc.view, true);
+    }, function (err) {
+      if (!i.dirty) i.local = null;
+      setInspStatus(errText(err), "err");
+    }).then(function () {
+      var again = i.dirty && !!i.local;
+      i.writing = false;
+      i.dirty = false;
+      if (again) { writeSelection(); return; }
+      var waiting = i.waiters.splice(0);
+      renderAll();
+      waiting.forEach(function (resolve) { resolve(); });
+    });
+  }
+  // Resolves when no selection write is in flight, so a Design round commits the selection the person sees.
+  function whenSelectionSettled() {
+    if (!state.insp.writing) return Promise.resolve();
+    return new Promise(function (resolve) { state.insp.waiters.push(resolve); });
+  }
+
+  // ---- search ----
+  function syncSearchButton(pane) {
+    if (pane.__search) pane.__search.disabled = !state.query.trim() || state.insp.searching;
+  }
+  function doSearch() {
+    var q = state.query.trim();
+    if (!q || state.insp.searching || !state.view) return;
+    state.insp.searching = true;
+    setInspStatus("", "");
+    renderAll();
+    callTool(TOOLS.inspire, { runDir: state.view.runDir, query: q }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.view) applyView(sc.view, true);
+    }, function (err) {
+      setInspStatus(err.code === "rate_limited" && err.retryAfterSeconds !== undefined ? tpl(COPY.tryAgain, { n: err.retryAfterSeconds }) : tpl(COPY.searchFailed, { message: errText(err) }), "err");
+    }).then(function () { state.insp.searching = false; renderAll(); });
+  }
+
+  // ---- the tab ----
+  function refButton(id) {
+    var b = button("", "refbtn");
+    b.setAttribute("aria-label", refName(id));
+    b.setAttribute("data-ref", id);
+    var img = el("img", "thumb empty");
+    img.alt = "";
+    b.appendChild(img);
+    bindReference(img, id, "thumb");
+    var check = el("span", "check");
+    check.innerHTML = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 12.5l4.5 4.5L19 7.5"/></svg>';
+    b.appendChild(check);
+    b.addEventListener("click", function () { toggleRef(id); });
+    return b;
+  }
+  function refSection(heading, title, ids) {
+    var sec = el("section", "refsec");
+    if (heading) {
+      var h = el("h2", "refhead", heading);
+      if (title) h.title = title;
+      sec.appendChild(h);
+    }
+    var grid = el("div", "refgrid");
+    ids.forEach(function (id) { grid.appendChild(refButton(id)); });
+    sec.appendChild(grid);
+    return sec;
+  }
+  function buildResults(box) {
+    var v = state.view;
+    var any = false;
+    var search = newestSearch();
+    if (search && search.referenceIds.length > 0) { box.appendChild(refSection("", "", search.referenceIds)); any = true; }
+    v.rounds.slice().sort(function (a, b) { return b.index - a.index; }).forEach(function (round) {
+      if (round.referenceIds.length === 0) return;
+      box.appendChild(refSection(COPY.roundPrefix + round.index, roundTitle(round), round.referenceIds));
+      any = true;
+    });
+    if (!any) box.appendChild(el("div", "placeholder", COPY.inspirationEmpty));
+  }
+  function buildInspirationShell(pane, where) {
+    pane.__built = true;
+    pane.classList.add("insp", where);
+    var row = el("div", "searchrow");
+    var input = el("input");
+    input.type = "text";
+    input.className = "query";
+    input.autocomplete = "off";
+    input.placeholder = COPY.inspirationPlaceholder;
+    input.setAttribute("aria-label", COPY.inspirationLabel);
+    input.value = state.query;
+    input.addEventListener("input", function () {
+      state.query = input.value;
+      var panes = document.querySelectorAll(".insp");
+      for (var i = 0; i < panes.length; i++) syncSearchButton(panes[i]);
+    });
+    input.addEventListener("keydown", function (e) { if (e.key === "Enter") doSearch(); });
+    var search = button(COPY.search, "primary", doSearch);
+    row.appendChild(input);
+    row.appendChild(search);
+    var status = el("div", "status");
+    status.setAttribute("data-istatus", "");
+    status.setAttribute("role", "status");
+    status.setAttribute("aria-live", "polite");
+    if (state.inspMsg) { status.textContent = state.inspMsg.text; if (state.inspMsg.kind) status.className = "status " + state.inspMsg.kind; }
+    pane.__input = input;
+    pane.__search = search;
+    pane.__results = el("div", "results");
+    pane.appendChild(row);
+    pane.appendChild(status);
+    pane.appendChild(pane.__results);
+  }
+  function renderInspiration(pane, where) {
+    if (!state.view) return;
+    if (!pane.__built) buildInspirationShell(pane, where);
+    syncSearchButton(pane);
+    var v = state.view;
+    var search = newestSearch();
+    var sig = JSON.stringify([search && [search.searchId, search.referenceIds], v.rounds.map(function (r) { return [r.index, r.kind, r.fromVersionId, r.referenceIds]; }), v.references]);
+    setIfChanged(pane.__results, sig, buildResults);
+    var chosen = currentSelected();
+    var buttons = pane.__results.querySelectorAll(".refbtn");
+    for (var i = 0; i < buttons.length; i++) buttons[i].setAttribute("aria-pressed", chosen.indexOf(buttons[i].getAttribute("data-ref")) >= 0 ? "true" : "false");
+  }
+`;
+//# sourceMappingURL=mcp-slate-ui-script-inspiration.js.map

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

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

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

@@ -0,0 +1,30 @@
+/**
+ * Generate more: the last tile of the thumbnails (the card's strip, the
+ * workspace's selection) and the panel it opens directly below them. The tile
+ * is an empty, very light thumbnail-sized box with a plus and no words; the
+ * panel is the heading, an optional note, how many (a segmented control) and
+ * Generate or Cancel. Clicking the tile again, Cancel or Escape collapses it.
+ *
+ * Generate starts a round through startRound, the very function the Design
+ * dialog uses for New options, so the run tool, the mode, the note and the
+ * selected inspiration are the same; the panel only adds the count.
+ *
+ * The same panel serves a thumbnail's plus (mcp-slate-ui-script-thumbtools.ts):
+ * "More like E2", with a tiny picture of that design, starts a round in mode
+ * "like" from that design's latest version. The tile opens the plain panel
+ * (mode "new"); opening either replaces the other, so neither carries the
+ * other's reference. While a
+ * round runs (or the request is in flight) the tile is off; the new round's
+ * pending options are already in the thumbnails, because the returned view
+ * carries them.
+ *
+ * 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.
+ */
+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

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