@12ui/design 0.2.73 → 0.2.75

package/runtime/codex-conversion/src/codex/home.mjs

@@ -1,7 +1,9 @@
-import { mkdtemp, symlink, copyFile, readFile, realpath, chmod } from 'node:fs/promises';
+import { mkdtemp, symlink, copyFile, readFile, realpath, chmod, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { spawnSync } from 'node:child_process';
+import { execFile } from 'node:child_process';
+
+const TEMP_HOME_PREFIX = '12ui-codex-';
 
 /** The planner receives an allowlisted environment, never provider credentials. @param {string} home */
 export function subscriptionEnv(home) {
@@ -20,18 +22,45 @@ export async function prepareHome({ authHome, binary, runDir, reasoning = 'low'
   if (authRoot === runRoot || authRoot.startsWith(runRoot + path.sep)) throw new Error('authHome must be outside runDir');
   const authPath = await realpath(path.join(authRoot, 'auth.json'));
   if (authPath === runRoot || authPath.startsWith(runRoot + path.sep)) throw new Error('Credentials must be outside runDir');
-  const home = await mkdtemp(path.join(tmpdir(), '12ui-codex-'));
-  await chmod(home, 0o700);
-  await symlink(authPath, path.join(home, 'auth.json'));
-  try { await copyFile(path.join(authRoot, 'models_cache.json'), path.join(home, 'models_cache.json')); }
-  catch (error) { throw new Error('Explicit authHome must contain models_cache.json', { cause: error }); }
-  const cache = JSON.parse(await readFile(path.join(home, 'models_cache.json'), 'utf8'));
-  if (!cache.models?.some(model => model.slug === 'gpt-6-astra' && model.supported_reasoning_levels?.some(level => level.effort === reasoning))) {
-    throw new Error(`Auth model cache does not support gpt-6-astra ${reasoning}`);
-  }
-  const login = spawnSync(binary, ['login', 'status'], { env: subscriptionEnv(home), encoding: 'utf8', timeout: 30000 });
-  if (login.status !== 0 || !`${login.stdout ?? ''}${login.stderr ?? ''}`.includes('Logged in using ChatGPT')) {
-    throw new Error('ChatGPT authentication unavailable; API authentication is not supported for the planner');
+  const home = await mkdtemp(path.join(tmpdir(), TEMP_HOME_PREFIX));
+  try {
+    await chmod(home, 0o700);
+    await symlink(authPath, path.join(home, 'auth.json'));
+    try { await copyFile(path.join(authRoot, 'models_cache.json'), path.join(home, 'models_cache.json')); }
+    catch (error) { throw new Error('Explicit authHome must contain models_cache.json', { cause: error }); }
+    const cache = JSON.parse(await readFile(path.join(home, 'models_cache.json'), 'utf8'));
+    if (!cache.models?.some(model => model.slug === 'gpt-6-astra' && model.supported_reasoning_levels?.some(level => level.effort === reasoning))) {
+      throw new Error(`Auth model cache does not support gpt-6-astra ${reasoning}`);
+    }
+    // Asynchronous, so parallel calls prepare their homes side by side instead of queueing on a blocked event loop.
+    const login = await new Promise(resolve => {
+      execFile(binary, ['login', 'status'], { env: subscriptionEnv(home), encoding: 'utf8', timeout: 30000 },
+        (error, stdout, stderr) => resolve({ ok: !error, output: `${stdout ?? ''}${stderr ?? ''}` }));
+    });
+    if (!login.ok || !login.output.includes('Logged in using ChatGPT')) {
+      throw new Error('ChatGPT authentication unavailable; API authentication is not supported for the planner');
+    }
+  } catch (error) {
+    // Nothing was dispatched from this home, so nothing will ever read it.
+    await removeTempHome(home);
+    throw error;
   }
   return { home, authentication: 'chatgpt' };
 }
+
+
+/**
+ * Remove one temp home this module made. Only a directory directly under the temp root whose name
+ * carries the temp-home prefix is ever removed, so a corrupted record cannot point this at a real home.
+ * @param {string | null | undefined} home
+ */
+export async function removeTempHome(home) {
+  if (!home) return;
+  const resolved = path.resolve(home);
+  const roots = new Set([path.resolve(tmpdir())]);
+  try { roots.add(await realpath(tmpdir())); } catch { /* the temp root itself is gone: nothing to match */ }
+  if (!roots.has(path.dirname(resolved)) || !path.basename(resolved).startsWith(TEMP_HOME_PREFIX)) {
+    throw new Error(`Refusing to remove ${resolved}: not a 12ui temp Codex home`);
+  }
+  await rm(resolved, { recursive: true, force: true });
+}

package/runtime/codex-conversion/src/images/native-files.mjs

@@ -9,3 +9,23 @@ export async function filesUnder(directory) {
  }
  return result.sort();
 }
+
+/**
+ * The file extension the bytes really are, so an attached input is named by its type
+ * (`reference.webp`, `reference-2.png`). Bytes of no recognised image type keep the
+ * historical `.png` name: they are not an image under any name, and the call reports that.
+ * @param {Uint8Array} bytes
+ */
+export function sniffImageExtension(bytes) {
+ const b=Buffer.from(bytes.buffer,bytes.byteOffset,bytes.byteLength);
+ if(b.length>=8&&b.subarray(0,8).equals(Buffer.from('89504e470d0a1a0a','hex')))return 'png';
+ if(b.length>=3&&b[0]===0xff&&b[1]===0xd8&&b[2]===0xff)return 'jpg';
+ if(b.length>=12&&b.toString('latin1',0,4)==='RIFF'&&b.toString('latin1',8,12)==='WEBP')return 'webp';
+ if(b.length>=6&&/^GIF8[79]a$/.test(b.toString('latin1',0,6)))return 'gif';
+ return 'png';
+}
+
+/** Attach-order input names: the first is `reference.<ext>`, the rest `reference-<n>.<ext>`. @param {Uint8Array[]} inputs */
+export function inputFileNames(inputs) {
+ return inputs.map((bytes,index)=>`${index===0?'reference':`reference-${index+1}`}.${sniffImageExtension(bytes)}`);
+}

package/runtime/codex-conversion/src/images/native-invoke.mjs

@@ -3,7 +3,7 @@ import path from 'node:path';
 import {spawn} from 'node:child_process';
 import {createWriteStream} from 'node:fs';
 import {finished} from 'node:stream/promises';
-import {subscriptionEnv} from '../codex/home.mjs';
+import {subscriptionEnv,removeTempHome} from '../codex/home.mjs';
 import {filesUnder} from './native-files.mjs';
 import {collectNative,packNativeReceipt} from './native-collect.mjs';
 
@@ -45,5 +45,8 @@ export async function invokeNative(spec, {callDir, persistMetadata}) {
   await fs.writeFile(path.join(callDir, 'completion.json'), JSON.stringify(completed, null, 2) + '\n', {flag: 'wx'});
   const rolloutPaths = (await filesUnder(path.join(auth.home, 'sessions')).catch(error => error.code === 'ENOENT' ? [] : Promise.reject(error))).filter(file => file.endsWith('.jsonl'));
   const receipt = await collectNative({rolloutPaths, outputDir: path.join(callDir, 'native-custody'), expected: spec.expected});
-  return {bytes: await packNativeReceipt(receipt), metadata: {...completed,nativeToolMs:receipt.toolMs,quotaBefore:receipt.quotaBefore,quotaAfter:receipt.quotaAfter,tokenUsage:receipt.tokenUsage}};
+  // The rollouts now live in the call's native-custody; the temp home (~66 MB) is removed. A call that dies
+  // before this line keeps its home, because recovery collects from it.
+  await removeTempHome(auth.home);
+  return {bytes: await packNativeReceipt(receipt), metadata: {...completed,nativeToolMs:receipt.toolMs,quotaBefore:receipt.quotaBefore,quotaAfter:receipt.quotaAfter,tokenUsage:receipt.tokenUsage,tempHomeRemoved:true}};
 }

package/runtime/codex-conversion/src/images/native-records.mjs

@@ -20,10 +20,10 @@ export function parseNativeRecords(text) {
     if(['error','turn_aborted'].includes(p.type)) diagnostics.push({timestamp:record.timestamp,...p});
     if (p.rate_limits) quota.push({line: index + 1, timestamp: record.timestamp, ...p.rate_limits});
     if (p.type === 'custom_tool_call' && p.name === 'exec') {
-      const count = (p.input?.match(/tools\.image_gen__imagegen\s*\(/g) ?? []).length;
-      if (count) calls.set(p.call_id, {callId: p.call_id, count, line: index + 1, timestamp: record.timestamp});
+      const prompts = imagegenPromptLiterals(p.input ?? '');
+      if (prompts.length) calls.set(p.call_id, {callId: p.call_id, count: prompts.length, prompts, line: index + 1, timestamp: record.timestamp});
     }
-    if (p.type === 'function_call' && /^(image_gen[._]imagegen|image_gen__imagegen)$/.test(p.name ?? '')) calls.set(p.call_id, {callId: p.call_id, count: 1, line: index + 1, timestamp: record.timestamp});
+    if (p.type === 'function_call' && /^(image_gen[._]imagegen|image_gen__imagegen)$/.test(p.name ?? '')) calls.set(p.call_id, {callId: p.call_id, count: 1, prompts: [functionCallPrompt(p.arguments)], line: index + 1, timestamp: record.timestamp});
     if (item?.kind === 'image_gen.generation' && p.type === 'item_completed') {
       const bytes = typeof item.result === 'string' ? Buffer.from(item.result, 'base64') : null;
       const entry = {id: item.id, status: item.status, failure: item.failure ?? null, savedPath: item.savedPath ?? null,
@@ -55,3 +55,75 @@ export function geometryTreatments(actual, expected) {
     selection: 'unselected-pending-multiple-case-registration-review',
   };
 }
+
+const ESCAPES = {n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', v: '\v', 0: '\0'};
+
+/**
+ * Decode the JavaScript string literal that opens at `start` (a ', " or ` quote). Returns the value and the index
+ * after the closing quote, or null when it is not one plain literal (a template with ${...}, or unterminated).
+ * @param {string} source @param {number} start
+ */
+function readStringLiteral(source, start) {
+  const quote = source[start];
+  if (!['"', "'", '`'].includes(quote)) return null;
+  let value = '';
+  for (let index = start + 1; index < source.length; index += 1) {
+    const char = source[index];
+    if (char === quote) return {value, end: index + 1};
+    if (quote === '`' && char === '$' && source[index + 1] === '{') return null;
+    if (char !== '\\') { value += char; continue; }
+    const next = source[index + 1];
+    if (next === undefined) return null;
+    if (next === 'u') {
+      const braced = source[index + 2] === '{' ? /^\{([0-9a-fA-F]+)\}/.exec(source.slice(index + 2)) : null;
+      const hex = braced ? braced[1] : /^[0-9a-fA-F]{4}/.exec(source.slice(index + 2))?.[0];
+      if (!hex) return null;
+      value += String.fromCodePoint(Number.parseInt(hex, 16));
+      index += 1 + (braced ? braced[0].length : 4);
+    } else if (next === 'x') {
+      const hex = /^[0-9a-fA-F]{2}/.exec(source.slice(index + 2))?.[0];
+      if (!hex) return null;
+      value += String.fromCharCode(Number.parseInt(hex, 16));
+      index += 3;
+    } else if (next === '\r' || next === '\n') {
+      // A line continuation adds nothing.
+      index += next === '\r' && source[index + 2] === '\n' ? 2 : 1;
+    } else {
+      value += Object.hasOwn(ESCAPES, next) ? ESCAPES[next] : next;
+      index += 1;
+    }
+  }
+  return null;
+}
+
+/**
+ * The `prompt` the nested driver passed to each `tools.image_gen__imagegen({...})` call in an exec input, one entry
+ * per call: the literal's value when it is one plain string literal, null when it is built some other way (a
+ * variable, a concatenation, a template with substitutions), which is then unknown rather than assumed.
+ * @param {string} input
+ * @returns {(string | null)[]}
+ */
+export function imagegenPromptLiterals(input) {
+  const prompts = [];
+  const call = /tools\.image_gen__imagegen\s*\(/g;
+  let match;
+  while ((match = call.exec(input))) {
+    const after = input.slice(match.index + match[0].length);
+    const next = /tools\.image_gen__imagegen\s*\(/.exec(after);
+    const scope = next ? after.slice(0, next.index) : after;
+    const key = /(?:^|[{,\s])(?:prompt|"prompt"|'prompt')\s*:\s*/.exec(scope);
+    if (!key) { prompts.push(null); continue; }
+    const literal = readStringLiteral(scope, key.index + key[0].length);
+    const following = literal ? scope.slice(literal.end).trimStart()[0] : undefined;
+    prompts.push(literal && (following === ',' || following === '}') ? literal.value : null);
+  }
+  return prompts;
+}
+
+/** @param {unknown} argumentsText */
+function functionCallPrompt(argumentsText) {
+  try {
+    const parsed = JSON.parse(String(argumentsText));
+    return typeof parsed?.prompt === 'string' ? parsed.prompt : null;
+  } catch { return null; }
+}

package/runtime/codex-conversion/src/images/native.mjs

@@ -2,10 +2,10 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import sharp from 'sharp';
-import {prepareHome} from '../codex/home.mjs';
+import {prepareHome,removeTempHome} from '../codex/home.mjs';
 import {invokeNative} from './native-invoke.mjs';
 import {collectNative,packNativeReceipt} from './native-collect.mjs';
-import {filesUnder} from './native-files.mjs';
+import {filesUnder,inputFileNames} from './native-files.mjs';
 import {sha256,pngDimensions,parseNativeRecords} from './native-records.mjs';
 
 export async function decodeNativeResponse(bytes) {
@@ -23,7 +23,8 @@ export async function executeNativeCall({request,input,callId,store,codexBinary=
   return store.runCall(callId,request,async({callDir,persistMetadata})=>{
     // One reference is the conversion case; a list attaches every image in order (design workspace edits and variations).
     const inputs=Array.isArray(input)?input:[input];
-    const referencePaths=inputs.map((_bytes,index)=>path.join(callDir,index===0?'reference.png':`reference-${index+1}.png`));
+    // Each input is named by its sniffed type (reference.webp, reference-2.png), never a blanket .png.
+    const referencePaths=inputFileNames(inputs).map(name=>path.join(callDir,name));
     for(const [index,bytes] of inputs.entries())await fs.writeFile(referencePaths[index],bytes,{flag:'wx'});
     const referencePath=referencePaths[0];
     const inspect=referencePaths.length===1?`Use tools.view_image once to inspect ${referencePath}.`:`Use tools.view_image once for each of these files, in this order: ${referencePaths.join(', ')}.`;
@@ -40,6 +41,8 @@ export async function executeNativeCall({request,input,callId,store,codexBinary=
     if(audit.state!=='completed-awaiting-dimensions')return null;
     const receipt=await collectNative({rolloutPaths,outputDir:path.join(callDir,'native-custody'),expected:request.expected});
     if(!['exact-size-pass','size-mismatch'].includes(receipt.state))return null;
-    return {bytes:await packNativeReceipt(receipt),metadata:{...metadata,nativeToolMs:receipt.toolMs,quotaBefore:receipt.quotaBefore,quotaAfter:receipt.quotaAfter,tokenUsage:receipt.tokenUsage,collectionRecovery:true}};
+    // Recovered and in custody: the temp home has nothing left that anything will read.
+    await removeTempHome(metadata.home);
+    return {bytes:await packNativeReceipt(receipt),metadata:{...metadata,nativeToolMs:receipt.toolMs,quotaBefore:receipt.quotaBefore,quotaAfter:receipt.quotaAfter,tokenUsage:receipt.tokenUsage,collectionRecovery:true,tempHomeRemoved:true}};
   }});
 }

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

@@ -1,23 +0,0 @@
-/**
- * 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

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

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

@@ -1,103 +0,0 @@
-/**
- * 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 const SLATE_UI_THUMBTOOLS = String.raw `
-  var ICON_PENCIL = "M4 20l1-4L16.5 4.5a2.1 2.1 0 0 1 3 3L8 19l-4 1zM14 7l3 3";
-
-  function thumbToolButton(action, label, path, c, onclick) {
-    var b = button("", "thumbtool", function (e) {
-      if (e && e.stopPropagation) e.stopPropagation();
-      onclick(c.candidateId);
-    });
-    b.setAttribute("aria-label", label);
-    b.title = label;
-    b.setAttribute("data-action", action);
-    b.setAttribute("data-candidate", c.candidateId);
-    b.innerHTML = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="' + path + '"/></svg>';
-    return b;
-  }
-
-  // One cell per option: the thumbnail button and, when there is a picture to work from, its two controls.
-  function thumbCell(c, cls) {
-    var cell = el("span", "thumbcell");
-    var thumb = thumbButton(c, cls);
-    if (thumb.classList.contains("selected")) cell.classList.add("selected");
-    cell.appendChild(thumb);
-    if (c.state === "ready" && latestVersion(c)) {
-      var tools = el("span", "thumbtools");
-      tools.appendChild(thumbToolButton("more", COPY.moreLikeThis, ICON_PLUS, c, openMoreLike));
-      tools.appendChild(thumbToolButton("edit", COPY.edit, ICON_PENCIL, c, editFromThumb));
-      cell.appendChild(tools);
-    }
-    return cell;
-  }
-
-  // Whether Edit has a dialog to open in this host: the workspace itself, or a card that can open the workspace.
-  function canEditHere() { return isFullscreen() || canFullscreen(); }
-
-  function thumbToolNodes() { return Array.prototype.slice.call(document.querySelectorAll(".thumbtool")); }
-  function thumbToolFor(action, candidateId) {
-    return thumbToolNodes().filter(function (t) {
-      return t.getAttribute("data-action") === action && t.getAttribute("data-candidate") === candidateId && !t.disabled && !isHiddenNode(t);
-    })[0];
-  }
-
-  function syncThumbTools() {
-    if (!state.view) return;
-    var busy = moreBusy();
-    var edit = canEditHere();
-    var likeId = state.more && state.more.mode === "like" ? state.more.fromCandidateId : null;
-    thumbToolNodes().forEach(function (t) {
-      var c = cand(t.getAttribute("data-candidate"));
-      var v = latestVersion(c);
-      if (t.getAttribute("data-action") === "more") {
-        t.disabled = busy || !pickable(v);
-        t.setAttribute("aria-expanded", likeId !== null && likeId === t.getAttribute("data-candidate") ? "true" : "false");
-      } else {
-        t.classList.toggle("hidden", !edit);
-        t.disabled = !v || !v.editable || !!(c && c.busy);
-      }
-    });
-  }
-
-  // Edit: that design is selected, then the Edit dialog opens on it, exactly as the workspace's Edit button does.
-  function editFromThumb(candidateId) {
-    var c = cand(candidateId);
-    var v = latestVersion(c);
-    if (!c || !v || !v.editable || c.busy || state.dialog) return;
-    selectCandidate(candidateId);
-    if (isFullscreen()) { openDialog("edit", thumbToolFor("edit", candidateId) || stageEls.edit); return; }
-    if (!canFullscreen()) return;
-    state.wantEdit = v.versionId;
-    request("ui/request-display-mode", { mode: "fullscreen" }).then(function (result) {
-      if (result && result.mode && result.mode !== "fullscreen") state.wantEdit = null;
-    }, function () { state.wantEdit = null; });
-  }
-  // The workspace has just shown: the dialog that was asked for in the card opens now, on the version that was asked for.
-  function openWantedEdit() {
-    var want = state.wantEdit;
-    if (!want || !stageBuilt || state.dialog) return;
-    state.wantEdit = null;
-    var v = selectedVersion();
-    if (v && v.versionId === want && v.editable) openDialog("edit", stageEls.edit);
-  }
-`;
-//# sourceMappingURL=mcp-slate-ui-script-thumbtools.js.map

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

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

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

@@ -1,10 +0,0 @@
-/**
- * The two controls on a design thumbnail (a plus and a pencil), and the cell
- * that holds them beside the thumbnail button. They sit in the top right corner
- * on a semi-opaque dark backdrop, so they stay legible over any picture, and
- * are shown only on hover or while keyboard focus is inside the cell. A device
- * with no hover shows them on the selected thumbnail only. A hidden control is
- * not clickable but stays focusable, and focus reveals it.
- */
-export declare const SLATE_UI_THUMBTOOLS_STYLES: string;
-//# sourceMappingURL=mcp-slate-ui-styles-thumbtools.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-slate-ui-styles-thumbtools.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-styles-thumbtools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,QAetC,CAAC"}

package/dist/mcp-slate-ui-styles-thumbtools.js

@@ -1,25 +0,0 @@
-/**
- * The two controls on a design thumbnail (a plus and a pencil), and the cell
- * that holds them beside the thumbnail button. They sit in the top right corner
- * on a semi-opaque dark backdrop, so they stay legible over any picture, and
- * are shown only on hover or while keyboard focus is inside the cell. A device
- * with no hover shows them on the selected thumbnail only. A hidden control is
- * not clickable but stays focusable, and focus reveals it.
- */
-export const SLATE_UI_THUMBTOOLS_STYLES = String.raw `
-  .thumbcell { position: relative; flex: none; display: block; }
-  .strip .thumbcell { width: 56px; height: 56px; }
-  .option .thumbcell { width: 72px; height: 72px; }
-  .thumbtools { position: absolute; top: 3px; right: 3px; display: flex; gap: 2px; opacity: 0; pointer-events: none; transition: opacity .12s; }
-  .thumbcell:hover .thumbtools, .thumbcell:focus-within .thumbtools { opacity: 1; pointer-events: auto; }
-  button.thumbtool { display: grid; place-items: center; flex: none; width: 22px; height: 22px; padding: 0; border: 0; border-radius: 5px; background: rgba(20, 20, 20, .62); color: #fff; }
-  button.thumbtool:hover:not(:disabled) { background: rgba(20, 20, 20, .85); }
-  button.thumbtool:focus-visible { outline: 2px solid var(--ring); outline-offset: 0; }
-  button.thumbtool:disabled { opacity: .5; }
-  @media (hover: none) {
-    .thumbtools { display: none; }
-    .thumbcell.selected .thumbtools { display: flex; opacity: 1; pointer-events: auto; }
-  }
-  @media (prefers-reduced-motion: reduce) { .thumbtools { transition: none; } }
-`;
-//# sourceMappingURL=mcp-slate-ui-styles-thumbtools.js.map

package/dist/mcp-slate-ui-styles-thumbtools.js.map

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