@12ui/design 0.2.76 → 0.2.78

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

@@ -0,0 +1,29 @@
+/**
+ * The person's language: which locale the screen speaks, and every word it shows, through `t(key, values)`.
+ *
+ * Where the locale comes from, first answer wins (each value must be a valid BCP 47 tag, else the next is asked):
+ * 1. `hostContext.locale` (MCP Apps), from `ui/initialize` and every `host-context-changed`;
+ * 2. `window.openai.locale` (the ChatGPT and Codex compatibility global);
+ * 3. the document's own `lang` as the host left it before this script ran (the screen's markup carries none, so a
+ *    value there is the host's: Codex sets it on the app's document before writing the screen into it);
+ * 4. the `locale` parameter of the frame's address (Codex's sandbox page carries it, and the app's document shares
+ *    that address);
+ * 5. `navigator.language` (in Codex the app's Accept-Language, not its UI language, so it comes last);
+ * 6. English.
+ *
+ * Read from Codex Desktop's own sandbox code on 2026-10-01: 1 to 4 all carry the Codex UI locale there (the shell
+ * builds `hostContext.locale`, sets `window.openai` and `lang` on the app's document from its address's `locale`, then
+ * writes the screen into that document). A tag maps to the closest shipped locale by language and script (zh-HK to Traditional, es-MX to
+ * Latin American Spanish, pt-PT to Brazilian Portuguese); a language that is not shipped is English, the source.
+ * `en-XA` is the pseudo-locale of the layout tests: English with every letter accented, bracketed and lengthened.
+ *
+ * Every catalogue ships in the document (no network under the host's policy). English stays baked in the static
+ * markup, so the first paint is never blank; `applyLocale` re-words it, and the view is drawn in the person's language
+ * from its first render. A locale that changes later (a host-context change) re-draws everything.
+ *
+ * Fragment of the view's script; String.raw, no backtick, no dollar-brace.
+ */
+export declare const SLATE_UI_L10N: string;
+/** The fragment with its catalogues and the embedded ICU functions in place. */
+export declare const buildSlateUiL10n: (messages: Record<string, Record<string, string>>) => string;
+//# sourceMappingURL=mcp-slate-ui-script-l10n.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,135 @@
+import { formatIcu, parseIcu, pseudoIcu } from './mcp-slate-ui-icu.js';
+import { matchShippedLocale } from './mcp-slate-ui-locale-match.js';
+/**
+ * The person's language: which locale the screen speaks, and every word it shows, through `t(key, values)`.
+ *
+ * Where the locale comes from, first answer wins (each value must be a valid BCP 47 tag, else the next is asked):
+ * 1. `hostContext.locale` (MCP Apps), from `ui/initialize` and every `host-context-changed`;
+ * 2. `window.openai.locale` (the ChatGPT and Codex compatibility global);
+ * 3. the document's own `lang` as the host left it before this script ran (the screen's markup carries none, so a
+ *    value there is the host's: Codex sets it on the app's document before writing the screen into it);
+ * 4. the `locale` parameter of the frame's address (Codex's sandbox page carries it, and the app's document shares
+ *    that address);
+ * 5. `navigator.language` (in Codex the app's Accept-Language, not its UI language, so it comes last);
+ * 6. English.
+ *
+ * Read from Codex Desktop's own sandbox code on 2026-10-01: 1 to 4 all carry the Codex UI locale there (the shell
+ * builds `hostContext.locale`, sets `window.openai` and `lang` on the app's document from its address's `locale`, then
+ * writes the screen into that document). A tag maps to the closest shipped locale by language and script (zh-HK to Traditional, es-MX to
+ * Latin American Spanish, pt-PT to Brazilian Portuguese); a language that is not shipped is English, the source.
+ * `en-XA` is the pseudo-locale of the layout tests: English with every letter accented, bracketed and lengthened.
+ *
+ * Every catalogue ships in the document (no network under the host's policy). English stays baked in the static
+ * markup, so the first paint is never blank; `applyLocale` re-words it, and the view is drawn in the person's language
+ * from its first render. A locale that changes later (a host-context change) re-draws everything.
+ *
+ * Fragment of the view's script; String.raw, no backtick, no dollar-brace.
+ */
+export const SLATE_UI_L10N = String.raw `
+  var MESSAGES = __MESSAGES__;
+  var parseIcu = (__PARSE_ICU__);
+  var formatIcu = (__FORMAT_ICU__);
+  var pseudoIcu = (__PSEUDO_ICU__);
+  var matchShippedLocale = (__MATCH_LOCALE__);
+  var PSEUDO_LOCALE = "en-XA";
+  var l10n = { tag: "", from: "", asked: "", hostLang: document.documentElement.getAttribute("lang") || "", parsed: {}, fmt: null, list: null };
+
+  function canonicalTag(value) {
+    if (typeof value !== "string" || !value.trim()) return null;
+    try { return Intl.getCanonicalLocales(value.trim().replace(/_/g, "-"))[0] || null; } catch (err) { return null; }
+  }
+  function frameLocale() {
+    try { return typeof location !== "undefined" && location.search ? new URLSearchParams(location.search).get("locale") : null; } catch (err) { return null; }
+  }
+  function localeChannels() {
+    var openai = typeof window.openai === "object" && window.openai ? window.openai.locale : null;
+    var nav = typeof navigator !== "undefined" && navigator ? ((navigator.languages && navigator.languages[0]) || navigator.language) : null;
+    return [["host", state.host.locale], ["openai", openai], ["lang", l10n.hostLang], ["url", frameLocale()], ["navigator", nav]];
+  }
+  function resolveLocale() {
+    var channels = localeChannels();
+    for (var i = 0; i < channels.length; i++) {
+      var tag = canonicalTag(channels[i][1]);
+      if (tag) return { tag: matchShippedLocale(tag, Object.keys(MESSAGES)), from: channels[i][0], asked: tag };
+    }
+    return { tag: "en", from: "default", asked: "" };
+  }
+
+  // ---- words ----
+  function hasMessage(key) { return Object.prototype.hasOwnProperty.call(MESSAGES.en, key); }
+  function t(key, values) {
+    var nodes = l10n.parsed[key];
+    if (!nodes) {
+      if (!hasMessage(key)) throw new Error("the catalogue has no message " + key);
+      var own = MESSAGES[l10n.tag];
+      var source = own && Object.prototype.hasOwnProperty.call(own, key) ? own[key] : MESSAGES.en[key];
+      nodes = parseIcu(source);
+      if (l10n.tag === PSEUDO_LOCALE) nodes = pseudoIcu(nodes);
+      l10n.parsed[key] = nodes;
+    }
+    return formatIcu(nodes, values || {}, l10n.fmt);
+  }
+  // A server's sentence in the person's language: its code's message with its values, or "" when the catalogue has no
+  // words for the code (or for a sentence inside its values), and the caller shows the server's own English instead.
+  function said(ref) {
+    if (!ref || typeof ref.code !== "string" || !hasMessage("server." + ref.code)) return "";
+    var values = {};
+    var params = ref.params || {};
+    for (var name in params) {
+      if (!Object.prototype.hasOwnProperty.call(params, name)) continue;
+      var value = params[name];
+      if (value && typeof value === "object") { value = said(value); if (!value) return ""; }
+      values[name] = value;
+    }
+    return t("server." + ref.code, values);
+  }
+  // Items joined as the person's language lists them ("A, B and C").
+  function listOf(items) { return l10n.list.format(items.map(String)); }
+  // Two whole sentences on one line, spaced as the language spaces them.
+  function sentences(first, second) { return first && second ? t("sentenceJoin", { first: first, second: second }) : first || second || ""; }
+
+  // ---- the static markup: data-l10n (words), data-l10n-aria (accessible name), data-l10n-label (name and tooltip) ----
+  function localizeStatic(root) {
+    var words = root.querySelectorAll("[data-l10n]");
+    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 labelled = root.querySelectorAll("[data-l10n-label]");
+    for (var k = 0; k < labelled.length; k++) {
+      var label = t(labelled[k].getAttribute("data-l10n-label"));
+      labelled[k].setAttribute("aria-label", label);
+      labelled[k].setAttribute("title", label);
+    }
+  }
+
+  // Applies the locale the channels name now. Returns true when it changed.
+  function applyLocale() {
+    var found = resolveLocale();
+    // Which channel decided, for the tests and for anyone inspecting a host: the host can confirm the language the
+    // screen already speaks (English from the browser, then English from the host), and that is news too.
+    l10n.from = found.from;
+    l10n.asked = found.asked;
+    document.documentElement.setAttribute("data-locale-from", found.from);
+    if (found.tag === l10n.tag) return false;
+    var intlTag = found.tag === PSEUDO_LOCALE ? "en" : found.tag;
+    var rules = new Intl.PluralRules(intlTag);
+    var numbers = new Intl.NumberFormat(intlTag);
+    l10n.tag = found.tag;
+    l10n.parsed = {};
+    l10n.fmt = { plural: function (n) { return rules.select(n); }, number: function (n) { return numbers.format(n); } };
+    l10n.list = new Intl.ListFormat(intlTag, { style: "long", type: "conjunction" });
+    document.documentElement.setAttribute("lang", found.tag);
+    document.title = t("title");
+    localizeStatic(document);
+    return true;
+  }
+  applyLocale();
+`;
+/** The fragment with its catalogues and the embedded ICU functions in place. */
+export const buildSlateUiL10n = (messages) => SLATE_UI_L10N
+    .replace('__MESSAGES__', () => JSON.stringify(messages))
+    .replace('__PARSE_ICU__', () => parseIcu.toString())
+    .replace('__FORMAT_ICU__', () => formatIcu.toString())
+    .replace('__PSEUDO_ICU__', () => pseudoIcu.toString())
+    .replace('__MATCH_LOCALE__', () => matchShippedLocale.toString());
+//# sourceMappingURL=mcp-slate-ui-script-l10n.js.map

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

@@ -0,0 +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"}

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

@@ -1,7 +1,8 @@
 /**
  * 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 a dashed, thumbnail-sized box with a plus and the words Generate more, pinned outside any scroll so it is always in view; the
+ * is a dashed, thumbnail-sized box with a plus and the words Generate more, the last tile of thumbnails that wrap
+ * rather than scroll sideways, so it is always in view; 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,
@@ -12,7 +13,7 @@
  * - the selected inspiration as small chips, each with a remove button that is
  *   the same selection write as the Inspiration tab's toggle (adding is done
  *   in that tab);
- * - an optional note, how many (1, 2, 4, 8 or 12, default 4) and Cancel and
+ * - 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

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

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

@@ -1,7 +1,8 @@
 /**
  * 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 a dashed, thumbnail-sized box with a plus and the words Generate more, pinned outside any scroll so it is always in view; the
+ * is a dashed, thumbnail-sized box with a plus and the words Generate more, the last tile of thumbnails that wrap
+ * rather than scroll sideways, so it is always in view; 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,
@@ -12,7 +13,7 @@
  * - the selected inspiration as small chips, each with a remove button that is
  *   the same selection write as the Inspiration tab's toggle (adding is done
  *   in that tab);
- * - an optional note, how many (1, 2, 4, 8 or 12, default 4) and Cancel and
+ * - 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
@@ -40,12 +41,12 @@ export const SLATE_UI_MORE = String.raw `
   // One tile per row of thumbnails; the strip and the selection each build their own.
   function moreTile() {
     var b = button("", "moretile", toggleMore);
-    b.setAttribute("aria-label", COPY.generateMore);
+    b.setAttribute("aria-label", t("generateMore"));
     b.setAttribute("aria-expanded", "false");
     b.setAttribute("aria-controls", "morepanel");
-    b.title = COPY.generateMore;
+    b.title = t("generateMore");
     b.innerHTML = '<svg viewBox="0 0 24 24" width="28" height="28" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" aria-hidden="true"><path d="' + ICON_PLUS + '"/></svg>';
-    b.appendChild(el("span", "", COPY.generateMore));
+    b.appendChild(el("span", "", t("generateMore")));
     return b;
   }
   function moreTiles() { return Array.prototype.slice.call(document.querySelectorAll(".moretile")); }
@@ -112,7 +113,7 @@ export const SLATE_UI_MORE = String.raw `
     var box = el("div", "morepanel");
     box.id = "morepanel";
     box.setAttribute("role", "group");
-    var title = el("h2", "morehead", COPY.generateMore);
+    var title = el("h2", "morehead", t("generateMore"));
     title.id = "morehead";
     box.setAttribute("aria-labelledby", "morehead");
     box.appendChild(title);
@@ -135,7 +136,7 @@ export const SLATE_UI_MORE = String.raw `
 
     // The inspiration that is selected, read back from the view; removing one is the tab's own selection write.
     m.els.chipsWrap = el("div", "morechips hidden");
-    m.els.chipsWrap.appendChild(el("span", "lbl", COPY.moreInspirationLabel));
+    m.els.chipsWrap.appendChild(el("span", "lbl", t("moreInspirationLabel")));
     m.els.chips = el("div", "refchips");
     m.els.chipsWrap.appendChild(m.els.chips);
     box.appendChild(m.els.chipsWrap);
@@ -143,14 +144,14 @@ export const SLATE_UI_MORE = String.raw `
     var note = el("textarea");
     note.setAttribute("rows", "2");
     note.setAttribute("maxlength", "600");
-    note.setAttribute("placeholder", COPY.moreNotePlaceholder);
-    note.setAttribute("aria-label", COPY.moreNotePlaceholder);
+    note.setAttribute("placeholder", t("moreNotePlaceholder"));
+    note.setAttribute("aria-label", t("moreNotePlaceholder"));
     note.addEventListener("input", function () { m.note = note.value; });
     box.appendChild(note);
     var row = el("div", "morerow");
     var seg = el("div", "seg");
     seg.setAttribute("role", "radiogroup");
-    seg.setAttribute("aria-label", COPY.moreCountLabel);
+    seg.setAttribute("aria-label", t("moreCountLabel"));
     MORE.choices.forEach(function (n) {
       var option = el("label", "segopt");
       var input = el("input");
@@ -166,8 +167,8 @@ export const SLATE_UI_MORE = String.raw `
     row.appendChild(seg);
     // Cancel and Generate stay together: on a narrow card they drop to the next line as a pair, at the right.
     var buttons = el("span", "morebtns");
-    buttons.appendChild(button(COPY.cancel, "", function () { closeMore(true); }));
-    m.els.primary = button(COPY.generate, "primary", commitMore);
+    buttons.appendChild(button(t("cancel"), "", function () { closeMore(true); }));
+    m.els.primary = button(t("generate"), "primary", commitMore);
     buttons.appendChild(m.els.primary);
     row.appendChild(buttons);
     box.appendChild(row);
@@ -185,9 +186,9 @@ export const SLATE_UI_MORE = String.raw `
     var selected = currentSelected().slice(0, MAX_SELECTED);
     m.els.toggle.checked = likeOn;
     m.els.toggle.disabled = !base || m.committing;
-    m.els.switchText.textContent = tpl(COPY.moreBasedOn, { label: base ? base.label : (selectedVersion() ? selectedVersion().label : "") });
-    m.els.switchText.parentNode.title = base ? "" : COPY.moreLikeUnavailable;
-    m.els.help.textContent = likeOn ? tpl(COPY.moreHelpLike, { label: base.label }) : selected.length > 0 ? COPY.moreHelpSelected : COPY.moreHelpFresh;
+    m.els.switchText.textContent = t("moreBasedOn", { label: base ? base.label : (selectedVersion() ? selectedVersion().label : "") });
+    m.els.switchText.parentNode.title = base ? "" : t("moreLikeUnavailable");
+    m.els.help.textContent = likeOn ? t("moreHelpLike", { label: base.label }) : selected.length > 0 ? t("moreHelpSelected") : t("moreHelpFresh");
     var shown = base || selectedVersion();
     var thumbSig = shown ? shown.versionId + ":" + shown.sha256 : "";
     if (m.thumbSig !== thumbSig) {
@@ -213,8 +214,8 @@ export const SLATE_UI_MORE = String.raw `
         chip.appendChild(img);
         bindReference(img, id, "thumb");
         var remove = button("", "refchipx", function () { toggleRef(id); });
-        remove.setAttribute("aria-label", tpl(COPY.removeReference, { name: refDescription(id) }));
-        remove.title = tpl(COPY.removeReference, { name: refDescription(id) });
+        remove.setAttribute("aria-label", t("removeReference", { name: refDescription(id) }));
+        remove.title = t("removeReference", { name: refDescription(id) });
         remove.innerHTML = '<svg viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" aria-hidden="true"><path d="M6 6l12 12M18 6L6 18"/></svg>';
         chip.appendChild(remove);
         m.els.chips.appendChild(chip);
@@ -273,7 +274,7 @@ export const SLATE_UI_MORE = String.raw `
     syncMoreBody(m);
     var local = localImage();
     m.els.primary.disabled = m.committing || busy || !local.ready;
-    m.els.alert.textContent = m.error || (!local.ready && local.reason ? local.reason : "");
+    m.els.alert.textContent = m.error || (!local.ready ? localReason() : "");
     m.els.alert.classList.toggle("hidden", !m.els.alert.textContent);
     // Fitted before the size report, so the host never sees the taller card.
     fitMore();

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * The inspiration pause (hosted server only; `rounds[].pause` in the view): a normal round waits for the person
+ * before it is drawn while this screen is in sight. The server owns every rule (workers/api/src/slate/store/pause.ts);
+ * this fragment shows the wait and sends the person's two answers.
+ *
+ * - The pause bar (in the card above the large image, in the workspace above the picture, and in the Inspiration tab
+ *   in place of Generate) says "Starting in 42 s. Change any reference, or press Continue." and counts down calmly:
+ *   the words change once a second (a timer role, so assistive technology is not told every second) and a thin line
+ *   shortens with them, without animation when motion is reduced. Change opens the Inspiration tab; Continue goes on.
+ * - Each option of the round shows the reference it will be drawn from, on its tile and in the large image, instead
+ *   of the drawing shimmer: nothing is being drawn yet.
+ * - Any touch of the screen (a press or click, a key, a wheel or touch scroll of the picker, focus in the search box)
+ *   holds the round. A wheel or touch counts only inside the picker's scrolling lists (the Inspiration results, the
+ *   workspace's selection): elsewhere, the inline card's large image say, it is the conversation being scrolled past
+ *   the card, which must not hold a round nobody then sees. A hold stops the countdown for good and the bar says
+ *   "Paused. Press Continue when ready." One hold is sent to the server. A scroll the page makes by itself (a grid
+ *   laid out again) is not a touch, so `scroll` is not listened to; the person's scrolling arrives as a wheel, a touch
+ *   or a key.
+ * - In the Inspiration tab the round's references are the round's own list until the person changes it: a tile there
+ *   adds or removes a reference (at most one per option), and Continue sends the list when it differs, which the
+ *   server gives the options in order.
+ * - A round that awaits a screen (`awaiting`, recorded before this screen existed) is seen at once with one status
+ *   call, which starts its countdown on the server.
+ *
+ * Fragment of the view's script; String.raw, no backtick, no dollar-brace.
+ */
+export declare const SLATE_UI_PAUSE: string;
+/**
+ * The local plugin's and the browser page's screens: their views never carry `rounds[].pause` (only the hosted server
+ * pauses), so the same names answer that nothing waits, and the document does not carry the pause's code.
+ */
+export declare const SLATE_UI_NO_PAUSE: string;
+//# sourceMappingURL=mcp-slate-ui-script-pause.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-slate-ui-script-pause.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-pause.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,QA4K1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAY7B,CAAC"}

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

@@ -0,0 +1,217 @@
+/**
+ * The inspiration pause (hosted server only; `rounds[].pause` in the view): a normal round waits for the person
+ * before it is drawn while this screen is in sight. The server owns every rule (workers/api/src/slate/store/pause.ts);
+ * this fragment shows the wait and sends the person's two answers.
+ *
+ * - The pause bar (in the card above the large image, in the workspace above the picture, and in the Inspiration tab
+ *   in place of Generate) says "Starting in 42 s. Change any reference, or press Continue." and counts down calmly:
+ *   the words change once a second (a timer role, so assistive technology is not told every second) and a thin line
+ *   shortens with them, without animation when motion is reduced. Change opens the Inspiration tab; Continue goes on.
+ * - Each option of the round shows the reference it will be drawn from, on its tile and in the large image, instead
+ *   of the drawing shimmer: nothing is being drawn yet.
+ * - Any touch of the screen (a press or click, a key, a wheel or touch scroll of the picker, focus in the search box)
+ *   holds the round. A wheel or touch counts only inside the picker's scrolling lists (the Inspiration results, the
+ *   workspace's selection): elsewhere, the inline card's large image say, it is the conversation being scrolled past
+ *   the card, which must not hold a round nobody then sees. A hold stops the countdown for good and the bar says
+ *   "Paused. Press Continue when ready." One hold is sent to the server. A scroll the page makes by itself (a grid
+ *   laid out again) is not a touch, so `scroll` is not listened to; the person's scrolling arrives as a wheel, a touch
+ *   or a key.
+ * - In the Inspiration tab the round's references are the round's own list until the person changes it: a tile there
+ *   adds or removes a reference (at most one per option), and Continue sends the list when it differs, which the
+ *   server gives the options in order.
+ * - A round that awaits a screen (`awaiting`, recorded before this screen existed) is seen at once with one status
+ *   call, which starts its countdown on the server.
+ *
+ * Fragment of the view's script; String.raw, no backtick, no dollar-brace.
+ */
+export const SLATE_UI_PAUSE = String.raw `
+  var PAUSE_COUNTDOWN_MS = 60000;
+  var PAUSE_TICK_MS = 1000;
+  var pause = { opId: null, roundId: null, endsAt: 0, held: false, chosen: null, sending: false, error: "", timer: null, asked: false, sighted: false };
+  function pauseClock() { return typeof performance !== "undefined" && performance.now ? performance.now() : Date.now(); }
+
+  function waitingRound() {
+    if (!state.view) return null;
+    var rounds = state.view.rounds.filter(function (r) { return !!r.pause; });
+    return rounds.length ? rounds[rounds.length - 1] : null;
+  }
+  function opOfRound(round) {
+    return state.view.ops.filter(function (o) { return o.kind === "round" && roundOfOp(o) === round && isRunning(o); })[0] || null;
+  }
+  function pauseActive() { return !!pause.opId; }
+  function pauseRound() { return pause.roundId ? roundById(pause.roundId) : null; }
+
+  function syncPause() {
+    var round = waitingRound();
+    var op = round && opOfRound(round);
+    if (!round || !op) { if (pause.opId) endPause(); return; }
+    if (pause.opId !== op.opId) {
+      endPause();
+      pause.opId = op.opId;
+      pause.roundId = round.roundId;
+    }
+    if (round.pause.state === "held") pause.held = true;
+    else if (!pause.held && round.pause.state === "countdown") { pause.endsAt = pauseClock() + round.pause.remainingMs; pause.asked = false; }
+    else if (!pause.held && round.pause.state === "awaiting") {
+      if (!pause.endsAt) pause.endsAt = pauseClock() + PAUSE_COUNTDOWN_MS;
+      if (!pause.sighted) { pause.sighted = true; setTimeout(refreshOnce, 0); }
+    }
+    if (pause.timer === null) pause.timer = setInterval(tickPause, PAUSE_TICK_MS);
+  }
+  function endPause() {
+    if (pause.timer !== null) clearInterval(pause.timer);
+    pause = { opId: null, roundId: null, endsAt: 0, held: false, chosen: null, sending: false, error: "", timer: null, asked: false, sighted: false };
+  }
+  function pauseLeftMs() { return Math.max(0, pause.endsAt - pauseClock()); }
+  function pauseText() {
+    if (pause.error) return pause.error;
+    if (pause.sending) return t("pauseStarting");
+    if (pause.held) return t("pauseHeld");
+    var left = Math.ceil(pauseLeftMs() / 1000);
+    return left > 0 ? t("pauseCountdown", { n: left }) : t("pauseStarting");
+  }
+  function tickPause() {
+    if (!pause.opId) return;
+    syncPauseBars();
+    if (!pause.held && !pause.asked && pauseLeftMs() <= 0) { pause.asked = true; refreshOnce(); }
+  }
+  function syncPauseBars() {
+    var words = pauseText();
+    var share = pause.held ? 0 : pauseLeftMs() / PAUSE_COUNTDOWN_MS;
+    var nodes = document.querySelectorAll("[data-pause-text]");
+    for (var i = 0; i < nodes.length; i++) if (nodes[i].textContent !== words) nodes[i].textContent = words;
+    var lines = document.querySelectorAll(".pauseline > span");
+    for (var j = 0; j < lines.length; j++) lines[j].style.transform = "scaleX(" + (Math.round(share * 1000) / 1000) + ")";
+    var lineBoxes = document.querySelectorAll(".pauseline");
+    for (var k = 0; k < lineBoxes.length; k++) lineBoxes[k].classList.toggle("hidden", pause.held || pause.sending);
+    var goes = document.querySelectorAll("[data-continue]");
+    for (var m = 0; m < goes.length; m++) goes[m].disabled = pause.sending || pauseChosen().length === 0;
+  }
+
+  function pauseChosen() {
+    if (pause.chosen) return pause.chosen;
+    var round = pauseRound();
+    return round ? round.referenceIds.slice() : [];
+  }
+  function sameList(a, b) { return a.length === b.length && a.every(function (id, i) { return b[i] === id; }); }
+  function pauseChanged() { var round = pauseRound(); return !!pause.chosen && !!round && !sameList(pause.chosen, round.referenceIds); }
+  function togglePauseRef(id) {
+    var round = pauseRound();
+    if (!round) return;
+    var cur = pauseChosen().slice();
+    var at = cur.indexOf(id);
+    if (at >= 0) cur.splice(at, 1);
+    else {
+      if (cur.length >= round.count) { setInspStatus(t("pauseAtMost", { n: round.count }), ""); return; }
+      cur.push(id);
+    }
+    setInspStatus(cur.length === 0 ? t("pauseNone") : "", "");
+    pause.chosen = cur;
+    renderAll();
+  }
+  function pausedFor(c) { return pauseActive() && c.roundId === pause.roundId && c.state === "pending"; }
+  function pausedRef(c) {
+    if (!pausedFor(c)) return null;
+    if (!pause.chosen) return c.referenceId || null;
+    var own = state.view.candidates.filter(function (x) { return x.roundId === c.roundId; }).sort(byLabel);
+    var chosen = pause.chosen;
+    return chosen.length ? chosen[own.indexOf(c) % chosen.length] : null;
+  }
+
+  function holdPause() {
+    if (!pause.opId || pause.held || pause.sending) return;
+    pause.held = true;
+    syncPauseBars();
+    callTool(TOOLS.run, { runDir: state.view.runDir, opId: pause.opId, action: { kind: "hold" } }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.view) applyView(sc.view, true);
+    }, function (err) { setStatus(errText(err), "err"); });
+  }
+  function continuePause() {
+    if (!pause.opId || pause.sending || pauseChosen().length === 0) return;
+    var action = { kind: "continue" };
+    if (pauseChanged()) action.referenceIds = pause.chosen.slice();
+    pause.sending = true;
+    pause.error = "";
+    syncPauseBars();
+    callTool(TOOLS.run, { runDir: state.view.runDir, opId: pause.opId, action: action }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.view) applyView(sc.view, true);
+    }, function (err) {
+      pause.sending = false;
+      pause.error = errText(err);
+      syncPauseBars();
+    });
+  }
+  // A wheel or a touch counts only where it scrolls the picker: the Inspiration results and the workspace's
+  // selection. Anywhere else (the card's large image, say) it is the person scrolling the conversation past the card.
+  var PICKER_SCROLLERS = ".results, .rail";
+  function onScreenTouch(e) {
+    if (!pause.opId || pause.held || pause.sending) return;
+    var t = e.target;
+    var inside = function (css) { return !!(t && t.closest && t.closest(css)); };
+    if (inside("[data-continue]")) return;
+    if (e.type === "focusin" && !(t && (t.tagName === "INPUT" || t.tagName === "TEXTAREA"))) return;
+    if ((e.type === "wheel" || e.type === "touchstart") && !inside(PICKER_SCROLLERS)) return;
+    holdPause();
+  }
+  ["pointerdown", "click", "keydown", "wheel", "touchstart", "focusin"].forEach(function (type) {
+    document.addEventListener(type, onScreenTouch, true);
+  });
+
+  function pauseBar(withChange) {
+    var bar = el("div", "pausebox");
+    bar.setAttribute("role", "group");
+    bar.setAttribute("aria-label", t("pauseLabel"));
+    var words = el("p", "pausetext", pauseText());
+    words.setAttribute("data-pause-text", "");
+    words.setAttribute("role", "timer");
+    bar.appendChild(words);
+    var actions = el("span", "pausebtns");
+    if (withChange) actions.appendChild(button(t("change"), "", function () { setTab("inspiration"); }));
+    var go = button(t("continueRound"), "primary", continuePause);
+    go.setAttribute("data-continue", "");
+    actions.appendChild(go);
+    bar.appendChild(actions);
+    var line = el("span", "pauseline");
+    line.setAttribute("aria-hidden", "true");
+    line.appendChild(el("span"));
+    bar.appendChild(line);
+    return bar;
+  }
+  function syncPauseHost(host, withChange) {
+    if (!host) return;
+    var sig = pause.opId ? pause.opId + (withChange ? ":change" : "") : "";
+    host.classList.toggle("hidden", !pause.opId);
+    if (host.__pause !== sig) {
+      host.__pause = sig;
+      host.textContent = "";
+      if (pause.opId) host.appendChild(pauseBar(withChange));
+    }
+  }
+  function pauseChoiceText() {
+    var round = pauseRound();
+    var chosen = pauseChosen();
+    if (!round) return "";
+    if (chosen.length === 0) return t("pauseNone");
+    return t("pauseFrom", { n: round.count, m: chosen.length });
+  }
+`;
+/**
+ * The local plugin's and the browser page's screens: their views never carry `rounds[].pause` (only the hosted server
+ * pauses), so the same names answer that nothing waits, and the document does not carry the pause's code.
+ */
+export const SLATE_UI_NO_PAUSE = String.raw `
+  var pause = { opId: null };
+  function pauseActive() { return false; }
+  function pauseRound() { return null; }
+  function pauseChosen() { return []; }
+  function pausedFor() { return false; }
+  function pausedRef() { return null; }
+  function togglePauseRef() {}
+  function syncPause() {}
+  function syncPauseBars() {}
+  function syncPauseHost(host) { if (host) host.classList.add("hidden"); }
+  function pauseChoiceText() { return ""; }
+`;
+//# sourceMappingURL=mcp-slate-ui-script-pause.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-slate-ui-script-pause.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-pause.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4KvC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;CAY1C,CAAC"}

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

@@ -4,6 +4,8 @@
  *
  * The messages. The host wraps every app message as untrusted input, so each one
  * names what happened and carries no command, flag, path, price or credit word;
+ * a Generate more or Edit click that the workspace runner on the person's Mac
+ * will draw sends none (remoteAfterRun);
  * the agent confirms through the model-visible data tool, which returns the
  * server's own trusted text. Six messages exist, one per click (spec v2 9.2):
  * Generate more with new options, Generate more based on a design, Edit,

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

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-remote.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,QAuH3B,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-remote.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,QA8J3B,CAAC"}