huhaa-myskills 0.2.13 → 0.3.4

package/packages/scanner/src/adapters/skill-adapter.mjs

@@ -0,0 +1,345 @@
+// skill-adapter.mjs — adapter for scanning generic SKILL.md files from other sources
+// Unlike markdown-skill.mjs which targets specific tools (hermes, claude-code),
+// this adapter provides a generic way to scan SKILL.md files from any source
+// and returns a standardized format with frontmatter parsing.
+
+import path from 'node:path';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fg from 'fast-glob';
+import {
+  expandRoots,
+  classifyRoot,
+  parseFrontmatter,
+  inferBrand,
+  inferProduct,
+  deriveDescription,
+  makePreview,
+  sha1Id,
+} from '../utils.mjs';
+
+const execFileP = promisify(execFile);
+
+/** Default concurrency for file reads — bounded by CPU count (R7.2). */
+const DEFAULT_CONCURRENCY = Math.max(4, Math.min(16, (os.cpus()?.length || 4)));
+
+/**
+ * Run an async mapper over items with a bounded concurrency pool.
+ * Keeps the event loop responsive and caps open file handles during scans.
+ * @template T,R
+ * @param {T[]} items
+ * @param {number} concurrency
+ * @param {(item: T, index: number) => Promise<R>} fn
+ * @returns {Promise<R[]>}
+ */
+async function mapWithConcurrency(items, concurrency, fn) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const workers = new Array(Math.min(concurrency, items.length || 1)).fill(0).map(async () => {
+    while (cursor < items.length) {
+      const i = cursor++;
+      results[i] = await fn(items[i], i);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+/**
+ * Scan SKILL.md files from arbitrary locations/sources
+ * @param {object} opts
+ * @param {string} opts.source              — IR source tag (e.g., 'other-skills', 'custom-skills')
+ * @param {string[]} opts.roots              — base dirs to scan (with ~ / globs)
+ * @param {string} [opts.fileGlob='SKILL.md'] — relative glob pattern
+ * @param {object} [opts.limits]             — { maxFiles, maxFileBytes }
+ * @param {'mini'|'full'} [opts.stage='full'] — 'mini' skips heavy fields for fast first paint (R7.1)
+ * @param {number} [opts.concurrency]        — parallel file reads (R7.2)
+ * @param {boolean} [opts.useSpotlight=false] — use `mdls` for timestamps (R7.3)
+ * @returns {Promise<{items:SkillItem[], stats:object}>}
+ */
+export async function scanSkills(opts) {
+  const {
+    source = 'other-skills',
+    roots = [],
+    fileGlob = '**/SKILL.md',
+    limits = { maxFiles: 5000, maxFileBytes: 1024 * 1024 },
+    stage = 'full',
+    concurrency = DEFAULT_CONCURRENCY,
+    useSpotlight = false,
+  } = opts;
+
+  const startedAt = Date.now();
+  const expanded = await expandRoots(roots);
+  if (!expanded.length) {
+    return { items: [], stats: { source, available: false, files: 0, stage } };
+  }
+
+  // Collect file paths
+  const files = [];
+  for (const root of expanded) {
+    const found = await fg(fileGlob, {
+      cwd: root,
+      absolute: true,
+      onlyFiles: true,
+      dot: true,
+      followSymbolicLinks: true,
+      deep: 10,
+      ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**'],
+    });
+    for (const f of found) {
+      files.push({ abs: f, root });
+      if (files.length >= limits.maxFiles) break;
+    }
+    if (files.length >= limits.maxFiles) break;
+  }
+
+  // Optional Spotlight timestamps (R7.3) — batched, best-effort.
+  const spotlightDates = useSpotlight ? await fetchSpotlightDates(files.map(f => f.abs)) : null;
+
+  // Parse each file concurrently (R7.2)
+  const items = await mapWithConcurrency(files, concurrency, ({ abs, root }) =>
+    parseSkillFile({ abs, root, source, limits, stage, spotlightDates }),
+  );
+
+  // Stable ordering by path (R3) — concurrency must not change output order.
+  items.sort((a, b) => (a.paths?.abs || '').localeCompare(b.paths?.abs || ''));
+
+  return {
+    items,
+    stats: {
+      source,
+      available: true,
+      files: items.length,
+      roots: expanded,
+      stage,
+      duration: Date.now() - startedAt,
+    },
+  };
+}
+
+/**
+ * Best-effort batched Spotlight timestamps via `mdls` (R7.3, opt-in).
+ * Returns a Map<abs, {creationDate?, contentChangeDate?}> or null on failure.
+ * @param {string[]} paths
+ * @returns {Promise<Map<string, {creationDate?: string, contentChangeDate?: string}>|null>}
+ */
+async function fetchSpotlightDates(paths) {
+  if (process.platform !== 'darwin' || !paths.length) return null;
+  const map = new Map();
+  const CHUNK = 50;
+  try {
+    for (let i = 0; i < paths.length; i += CHUNK) {
+      const chunk = paths.slice(i, i + CHUNK);
+      const { stdout } = await execFileP('mdls', [
+        '-name', 'kMDItemFSCreationDate',
+        '-name', 'kMDItemFSContentChangeDate',
+        '-raw',
+        ...chunk,
+      ]);
+      // -raw emits values separated by NUL, in order: [creation, change] per file.
+      const values = stdout.split('\0');
+      for (let j = 0; j < chunk.length; j++) {
+        const creation = values[j * 2];
+        const change = values[j * 2 + 1];
+        const entry = {};
+        if (creation && creation !== '(null)') entry.creationDate = toIso(creation);
+        if (change && change !== '(null)') entry.contentChangeDate = toIso(change);
+        if (entry.creationDate || entry.contentChangeDate) map.set(chunk[j], entry);
+      }
+    }
+    return map;
+  } catch {
+    return null;
+  }
+}
+
+function toIso(mdlsDate) {
+  // mdls raw date looks like "2026-07-01 10:30:00 +0000"
+  const d = new Date(mdlsDate.replace(' +', '+').replace(/ (\d{4})$/, ' +$1'));
+  return Number.isNaN(d.getTime()) ? undefined : d.toISOString();
+}
+
+/**
+ * Read a file safely with async I/O + byte limit (R7.2).
+ * @returns {Promise<{text:string, truncated:boolean, mtime:Date, error?:string}>}
+ */
+async function readFileSafeAsync(abs, maxBytes) {
+  try {
+    const stat = await fsp.stat(abs);
+    if (stat.size > maxBytes) {
+      return { text: '', truncated: true, mtime: stat.mtime };
+    }
+    return { text: await fsp.readFile(abs, 'utf8'), truncated: false, mtime: stat.mtime };
+  } catch (e) {
+    return { text: '', truncated: false, mtime: new Date(0), error: e.message };
+  }
+}
+
+/**
+ * Parse a single SKILL.md file
+ * @param {object} opts
+ * @param {string} opts.abs     — absolute path to the SKILL.md file
+ * @param {string} opts.root    — root directory for relative path calculation
+ * @param {string} opts.source  — source identifier
+ * @param {object} opts.limits  — { maxFileBytes }
+ * @param {'mini'|'full'} opts.stage — 'mini' skips heavy fields (R7.1)
+ * @param {Map|null} opts.spotlightDates — optional Spotlight timestamps (R7.3)
+ * @returns {Promise<SkillItem>}
+ */
+async function parseSkillFile({ abs, root, source, limits, stage = 'full', spotlightDates = null }) {
+  const { text, truncated, mtime, error } = await readFileSafeAsync(abs, limits.maxFileBytes);
+  const id = sha1Id(abs);
+  const rel = path.relative(root, abs);
+
+  // Extract category from directory structure
+  const relDir = path.dirname(rel);
+  const category = relDir && relDir !== '.' ? relDir.split('/')[0] : undefined;
+
+  // Extract skill name from parent directory
+  const dirName = path.basename(path.dirname(abs));
+
+  const updatedAt =
+    spotlightDates?.get(abs)?.contentChangeDate || new Date(mtime).toISOString();
+
+  // Handle file read errors
+  if (error) {
+    return createBaseItem({ abs, id, source, dirName, category, updatedAt, raw: '', parseError: error });
+  }
+
+  // Handle truncated files
+  if (truncated) {
+    return createBaseItem({
+      abs,
+      id,
+      source,
+      dirName,
+      category,
+      updatedAt,
+      raw: '',
+      parseError: `file > ${limits.maxFileBytes} bytes, skipped`,
+    });
+  }
+
+  // Parse frontmatter
+  const { data: fm, body, i18n, parseError } = parseFrontmatter(text);
+
+  const name = (fm.name || dirName).toString().trim();
+  const title = (fm.title || fm.name || dirName).toString().trim();
+  const description = deriveDescription(fm, body);
+
+  // Explicit icon override from frontmatter (e.g. "emoji:🤖", "url:...", "app:bundleId")
+  const icon = typeof fm.icon === 'string' ? fm.icon.trim() : undefined;
+
+  // Build the item — 'mini' stage omits heavy fields for a fast first paint (R7.1).
+  const item = {
+    id,
+    kind: 'skill',
+    source,
+    editor: 'Other Skills',
+    name,
+    title: title !== name ? title : undefined,
+    description,
+    category,
+    icon,
+    paths: {
+      abs,
+      rel,
+      rootKind: classifyRoot(abs),
+    },
+    updatedAt,
+  };
+
+  // Infer brand (needed by both stages for icon resolution)
+  item.brand = inferBrand({ name, description, category, raw: stage === 'mini' ? description : body });
+
+  if (stage !== 'mini') {
+    const triggers = collectTriggers(fm);
+    const tags = collectTags(fm);
+    const links = collectLinks(fm);
+    item.triggers = triggers.length ? triggers : undefined;
+    item.tags = tags.length ? tags : undefined;
+    item.preview = makePreview(body);
+    item.raw = text;
+    item.links = links.length ? links : undefined;
+    item.product = inferProduct({ name, category });
+
+    if (i18n) {
+      item.i18n = {
+        ...i18n,
+        translatedAt: new Date().toISOString(),
+        translationModel: 'frontmatter',
+      };
+    }
+  }
+
+  if (parseError) item.parseError = parseError;
+  return item;
+}
+
+/**
+ * Create a minimal skill item for error cases
+ */
+function createBaseItem({ abs, id, source, dirName, category, updatedAt, raw, parseError }) {
+  return {
+    id,
+    kind: 'skill',
+    source,
+    editor: 'Other Skills',
+    name: dirName,
+    description: undefined,
+    category,
+    paths: { abs, rootKind: classifyRoot(abs) },
+    preview: '',
+    raw,
+    updatedAt,
+    parseError,
+  };
+}
+
+/**
+ * Collect trigger strings from frontmatter
+ */
+function collectTriggers(fm) {
+  const out = [];
+  const candidates = [fm.triggers, fm.aliases, fm.when_to_use];
+  for (const c of candidates) {
+    if (!c) continue;
+    if (Array.isArray(c)) {
+      out.push(...c.filter(x => typeof x === 'string').map(x => x.trim()));
+    } else if (typeof c === 'string') {
+      out.push(c.trim());
+    }
+  }
+  return [...new Set(out)];
+}
+
+/**
+ * Collect tags from frontmatter
+ */
+function collectTags(fm) {
+  const v = fm.tags;
+  if (!v) return [];
+  if (Array.isArray(v)) return v.filter(x => typeof x === 'string');
+  if (typeof v === 'string') return v.split(',').map(s => s.trim()).filter(Boolean);
+  return [];
+}
+
+/**
+ * Collect links from frontmatter
+ */
+function collectLinks(fm) {
+  const out = [];
+  if (Array.isArray(fm.links)) {
+    for (const l of fm.links) {
+      if (l && typeof l === 'object' && l.url) {
+        out.push({ label: l.label || l.url, url: l.url });
+      }
+    }
+  }
+  if (typeof fm.url === 'string') {
+    out.push({ label: 'docs', url: fm.url });
+  }
+  return out;
+}

package/packages/scanner/src/icon/brand-map.mjs

@@ -0,0 +1,84 @@
+// brand-map.mjs — maps a skill's brand/source to candidate macOS applications.
+//
+// Used by icon-extractor.mjs to locate the real .app bundle for a skill so its
+// genuine editor/tool icon can be shown (mirrors Pearcleaner's app-icon logic).
+//
+// Bundle IDs are the fast/accurate path (mdfind); appNames are the fallback
+// (scan /Applications). Entries with neither map to nothing → emoji fallback.
+
+/**
+ * @typedef {object} BrandAppSpec
+ * @property {string[]} bundleIds  — candidate CFBundleIdentifier values
+ * @property {string[]} appNames   — candidate .app display names (no extension)
+ * @property {string}  [emoji]     — emoji fallback when no app is found
+ */
+
+/** @type {Record<string, BrandAppSpec>} */
+export const BRAND_APP_MAP = {
+  cursor: {
+    bundleIds: ['com.todesktop.230313mzl4w4u92'],
+    appNames: ['Cursor'],
+    emoji: '🖱️',
+  },
+  'vs-code': {
+    bundleIds: ['com.microsoft.VSCode', 'com.microsoft.VSCodeInsiders'],
+    appNames: ['Visual Studio Code', 'Code', 'Visual Studio Code - Insiders'],
+    emoji: '📝',
+  },
+  vscode: {
+    bundleIds: ['com.microsoft.VSCode'],
+    appNames: ['Visual Studio Code', 'Code'],
+    emoji: '📝',
+  },
+  'claude-code': {
+    bundleIds: ['com.anthropic.claude', 'com.anthropic.claudefordesktop'],
+    appNames: ['Claude'],
+    emoji: '🤖',
+  },
+  claude: {
+    bundleIds: ['com.anthropic.claude', 'com.anthropic.claudefordesktop'],
+    appNames: ['Claude'],
+    emoji: '🤖',
+  },
+  obsidian: {
+    bundleIds: ['md.obsidian'],
+    appNames: ['Obsidian'],
+    emoji: '🧠',
+  },
+  docker: {
+    bundleIds: ['com.docker.docker'],
+    appNames: ['Docker', 'Docker Desktop'],
+    emoji: '🐳',
+  },
+  // Tools that usually have no GUI .app on macOS → emoji fallback only.
+  codex: { bundleIds: [], appNames: ['Codex'], emoji: '📋' },
+  hermes: { bundleIds: [], appNames: ['Hermes'], emoji: '⚡' },
+  mcp: { bundleIds: [], appNames: [], emoji: '🔌' },
+};
+
+/**
+ * Resolve a brand/source key (or a raw bundle id) into a lookup spec.
+ * A value containing a dot is treated as an explicit bundle id.
+ * @param {string} key
+ * @returns {BrandAppSpec | null}
+ */
+export function resolveBrandSpec(key) {
+  if (!key) return null;
+  const normalized = String(key).toLowerCase().trim();
+  if (BRAND_APP_MAP[normalized]) return BRAND_APP_MAP[normalized];
+  // Looks like a bundle identifier (e.g. "com.microsoft.VSCode")
+  if (/^[a-z0-9-]+(\.[a-z0-9-]+)+$/i.test(key)) {
+    return { bundleIds: [key], appNames: [], emoji: undefined };
+  }
+  return null;
+}
+
+/**
+ * Emoji fallback for a brand/source key (used when no app is found).
+ * @param {string} key
+ * @returns {string | undefined}
+ */
+export function emojiForBrand(key) {
+  const spec = BRAND_APP_MAP[String(key || '').toLowerCase().trim()];
+  return spec?.emoji;
+}

package/packages/scanner/src/icon/icon-extractor.mjs

@@ -0,0 +1,246 @@
+// icon-extractor.mjs — extract real macOS application icons for skills.
+//
+// Node.js equivalent of Pearcleaner's NSWorkspace.icon(forFile:) using only
+// macOS built-in CLIs (mdfind / plutil / sips). No native bindings.
+//
+//   1. locateApp()      — find the .app bundle for a brand (mdfind + /Applications)
+//   2. extractIconPng() — read CFBundleIconFile from Info.plist, sips → PNG
+//   3. getIconForBrand()— combine + disk cache (mtime-invalidated)
+//   4. resolveIconRef() — sync: decide iconUrl / emoji fallback for a skill
+//
+// All extraction is lazy (on /api/icons request) and cached, so scanning stays
+// fast and non-macOS platforms degrade gracefully to emoji.
+
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { resolveBrandSpec, emojiForBrand } from './brand-map.mjs';
+
+const execFileP = promisify(execFile);
+const IS_MACOS = process.platform === 'darwin';
+const APP_DIRS = [
+  '/Applications',
+  path.join(os.homedir(), 'Applications'),
+  '/System/Applications',
+];
+const VALID_SIZES = new Set([32, 64, 128]);
+
+// In-memory caches (per process). locateApp is stable within a session.
+const appPathCache = new Map(); // brand -> appPath|null
+const iconPathCache = new Map(); // `${brand}:${size}` -> pngPath|null
+
+function cacheDir() {
+  const base =
+    process.env.HUHAA_HOME?.trim() ||
+    path.join(process.env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), '.config'), 'huhaa-myskills');
+  return path.join(expandTilde(base), 'icon-cache');
+}
+
+function expandTilde(p) {
+  if (!p) return p;
+  if (p === '~' || p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+
+function slugify(s) {
+  return String(s).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Locate the .app bundle for a brand/source key (or raw bundle id).
+ * @param {string} brand
+ * @returns {Promise<string|null>} absolute path to the .app or null
+ */
+export async function locateApp(brand) {
+  if (!IS_MACOS || !brand) return null;
+  const key = String(brand).toLowerCase().trim();
+  if (appPathCache.has(key)) return appPathCache.get(key);
+
+  const spec = resolveBrandSpec(brand);
+  if (!spec) {
+    appPathCache.set(key, null);
+    return null;
+  }
+
+  let found = null;
+
+  // 1. Bundle ID via Spotlight — fastest and most accurate.
+  for (const bundleId of spec.bundleIds) {
+    const p = await mdfindBundle(bundleId);
+    if (p) {
+      found = p;
+      break;
+    }
+  }
+
+  // 2. App-name scan of /Applications (case-insensitive) as fallback.
+  if (!found) {
+    found = scanAppDirs(spec.appNames);
+  }
+
+  appPathCache.set(key, found);
+  return found;
+}
+
+async function mdfindBundle(bundleId) {
+  try {
+    const { stdout } = await execFileP('mdfind', [
+      `kMDItemCFBundleIdentifier == '${bundleId}'`,
+    ]);
+    const first = stdout.split('\n').map(s => s.trim()).find(s => s.endsWith('.app') && fs.existsSync(s));
+    return first || null;
+  } catch {
+    return null;
+  }
+}
+
+function scanAppDirs(appNames) {
+  if (!appNames?.length) return null;
+  const wanted = new Set(appNames.map(n => `${n.toLowerCase()}.app`));
+  for (const dir of APP_DIRS) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (wanted.has(entry.toLowerCase())) {
+        return path.join(dir, entry);
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract a PNG icon from an .app bundle at the given size, with disk cache.
+ * Cache is invalidated when the .app's mtime is newer than the cached PNG.
+ * @param {string} appPath  — absolute path to a .app bundle
+ * @param {number} size     — 32 | 64 | 128
+ * @returns {Promise<string|null>} path to the cached PNG or null
+ */
+export async function extractIconPng(appPath, size) {
+  if (!IS_MACOS || !appPath) return null;
+  const dir = cacheDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const pngPath = path.join(dir, `${slugify(path.basename(appPath, '.app'))}-${size}.png`);
+
+  // Reuse cache if fresh (app not modified since PNG was written).
+  try {
+    const appStat = fs.statSync(appPath);
+    const pngStat = fs.statSync(pngPath);
+    if (pngStat.mtimeMs >= appStat.mtimeMs) return pngPath;
+  } catch {
+    // png missing → fall through to (re)build
+  }
+
+  const icnsPath = await findIcnsPath(appPath);
+  if (!icnsPath) return null;
+
+  try {
+    await execFileP('sips', ['-s', 'format', 'png', '-Z', String(size), icnsPath, '--out', pngPath]);
+    return fs.existsSync(pngPath) ? pngPath : null;
+  } catch {
+    return null;
+  }
+}
+
+async function findIcnsPath(appPath) {
+  const resourcesDir = path.join(appPath, 'Contents', 'Resources');
+  const infoPlist = path.join(appPath, 'Contents', 'Info.plist');
+
+  // Preferred: CFBundleIconFile from Info.plist
+  let iconFile = null;
+  try {
+    const { stdout } = await execFileP('plutil', ['-extract', 'CFBundleIconFile', 'raw', infoPlist]);
+    iconFile = stdout.trim();
+  } catch {
+    // key absent — fall back to directory scan
+  }
+
+  if (iconFile) {
+    const withExt = iconFile.endsWith('.icns') ? iconFile : `${iconFile}.icns`;
+    const candidate = path.join(resourcesDir, withExt);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  // Fallback: first .icns in Resources (prefer one containing "icon").
+  try {
+    const icns = fs.readdirSync(resourcesDir).filter(f => f.toLowerCase().endsWith('.icns'));
+    if (!icns.length) return null;
+    const preferred = icns.find(f => /icon/i.test(f)) || icns[0];
+    return path.join(resourcesDir, preferred);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get a cached PNG icon path for a brand at a given size (locate + extract).
+ * @param {string} brand
+ * @param {number} [size=64]
+ * @returns {Promise<string|null>}
+ */
+export async function getIconForBrand(brand, size = 64) {
+  if (!IS_MACOS) return null;
+  const sz = VALID_SIZES.has(size) ? size : 64;
+  const key = `${String(brand).toLowerCase().trim()}:${sz}`;
+  if (iconPathCache.has(key)) {
+    const cached = iconPathCache.get(key);
+    if (cached && fs.existsSync(cached)) return cached;
+  }
+  const appPath = await locateApp(brand);
+  if (!appPath) {
+    iconPathCache.set(key, null);
+    return null;
+  }
+  const png = await extractIconPng(appPath, sz);
+  iconPathCache.set(key, png);
+  return png;
+}
+
+/**
+ * Decide the icon reference for a skill WITHOUT touching the filesystem/spawns.
+ * Implements the R6.5 priority chain:
+ *   explicit frontmatter.icon > real app icon (brand/source) > emoji fallback
+ *
+ * @param {object} skill
+ * @param {string} [skill.icon]    — explicit frontmatter icon ("emoji:🤖"/"url:.."/"app:bundleId")
+ * @param {string} [skill.brand]
+ * @param {string} [skill.source]
+ * @param {number} [size=64]
+ * @returns {{ iconUrl?: string, iconFallback?: string }}
+ */
+export function resolveIconRef(skill, size = 64) {
+  const sz = VALID_SIZES.has(size) ? size : 64;
+  const icon = skill?.icon ? String(skill.icon).trim() : '';
+
+  // 1. Explicit frontmatter override
+  if (icon) {
+    if (icon.startsWith('emoji:')) return { iconFallback: icon.slice(6) };
+    if (icon.startsWith('url:')) return { iconUrl: icon.slice(4) };
+    if (icon.startsWith('app:')) {
+      return { iconUrl: `/api/icons/${encodeURIComponent(icon.slice(4))}?size=${sz}` };
+    }
+    // A bare emoji / single glyph
+    return { iconFallback: icon };
+  }
+
+  // 2. Real app icon by brand, then source
+  for (const key of [skill?.brand, skill?.source]) {
+    if (key && resolveBrandSpec(key)) {
+      return {
+        iconUrl: `/api/icons/${encodeURIComponent(key)}?size=${sz}`,
+        iconFallback: emojiForBrand(key),
+      };
+    }
+  }
+
+  // 3. No mapping — frontend emoji map handles it
+  return {};
+}
+
+export { IS_MACOS };