@stacksjs/stx 0.2.95 → 0.2.97

package/dist/story/props-validation.js

@@ -1,2 +1,215 @@
-// @bun
-import{la as a,ma as b,na as c,oa as d,pa as e}from"../chunk-095s3972.js";import"../chunk-xv34zbp4.js";export{a as validateProps,e as getValidationStyles,b as getValidationScript,d as generateValidationErrorsHTML,c as formatValidationResult};
+export function validateProps(props, definitions) {
+  const errors = [], warnings = [];
+  for (const def of definitions)
+    if (def.required && !(def.name in props))
+      errors.push({
+        prop: def.name,
+        message: `Required prop "${def.name}" is missing`,
+        expected: def.type
+      });
+  for (const [name, value] of Object.entries(props)) {
+    const def = definitions.find((d) => d.name === name);
+    if (!def) {
+      warnings.push({
+        prop: name,
+        message: `Unknown prop "${name}" - not defined in component`
+      });
+      continue;
+    }
+    const typeError = validateType(value, def.type, def.options);
+    if (typeError)
+      errors.push({
+        prop: name,
+        message: typeError,
+        expected: def.type,
+        actual: typeof value
+      });
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateType(value, type, options) {
+  if (value === null || value === void 0) {
+    if (type.includes("null") || type.includes("undefined") || type.includes("?"))
+      return null;
+    return `Expected ${type}, got ${value === null ? "null" : "undefined"}`;
+  }
+  const actualType = typeof value, normalizedType = type.toLowerCase().trim();
+  if (normalizedType.includes("|")) {
+    const types = normalizedType.split("|").map((t) => t.trim());
+    for (const t of types)
+      if (validateType(value, t, options) === null)
+        return null;
+    return `Expected one of ${types.join(" | ")}, got ${actualType}`;
+  }
+  if (options && options.length > 0) {
+    if (!options.includes(String(value)))
+      return `Expected one of [${options.join(", ")}], got "${value}"`;
+    return null;
+  }
+  switch (normalizedType) {
+    case "string":
+      if (actualType !== "string")
+        return `Expected string, got ${actualType}`;
+      break;
+    case "number":
+      if (actualType !== "number" || Number.isNaN(value))
+        return `Expected number, got ${actualType}`;
+      break;
+    case "boolean":
+      if (actualType !== "boolean")
+        return `Expected boolean, got ${actualType}`;
+      break;
+    case "array":
+    case "any[]":
+    case "array<any>":
+      if (!Array.isArray(value))
+        return `Expected array, got ${actualType}`;
+      break;
+    case "object":
+    case "record<string, any>":
+      if (actualType !== "object" || Array.isArray(value))
+        return `Expected object, got ${actualType}`;
+      break;
+    case "function":
+      if (actualType !== "function")
+        return `Expected function, got ${actualType}`;
+      break;
+    case "any":
+      break;
+    default:
+      if (normalizedType.startsWith("array<") || normalizedType.endsWith("[]")) {
+        if (!Array.isArray(value))
+          return `Expected array, got ${actualType}`;
+      }
+  }
+  return null;
+}
+export function getValidationScript(definitions) {
+  return `
+    window.__stxValidateProps = function(props) {
+      const definitions = ${JSON.stringify(definitions)};
+      const errors = [];
+      const warnings = [];
+
+      // Check required props
+      for (const def of definitions) {
+        if (def.required && !(def.name in props)) {
+          errors.push({
+            prop: def.name,
+            message: 'Required prop "' + def.name + '" is missing',
+            expected: def.type
+          });
+        }
+      }
+
+      // Validate provided props
+      for (const [name, value] of Object.entries(props)) {
+        const def = definitions.find(d => d.name === name);
+
+        if (!def) {
+          warnings.push({
+            prop: name,
+            message: 'Unknown prop "' + name + '"'
+          });
+          continue;
+        }
+
+        // Basic type validation
+        const actualType = typeof value;
+        const expectedType = def.type.toLowerCase();
+
+        if (expectedType === 'string' && actualType !== 'string') {
+          errors.push({ prop: name, message: 'Expected string, got ' + actualType });
+        }
+else if (expectedType === 'number' && actualType !== 'number') {
+          errors.push({ prop: name, message: 'Expected number, got ' + actualType });
+        }
+else if (expectedType === 'boolean' && actualType !== 'boolean') {
+          errors.push({ prop: name, message: 'Expected boolean, got ' + actualType });
+        }
+else if (expectedType === 'array' && !Array.isArray(value)) {
+          errors.push({ prop: name, message: 'Expected array, got ' + actualType });
+        }
+
+        // Check options
+        if (def.options && def.options.length > 0) {
+          if (!def.options.includes(String(value))) {
+            errors.push({
+              prop: name,
+              message: 'Expected one of [' + def.options.join(', ') + '], got "' + value + '"'
+            });
+          }
+        }
+      }
+
+      return { valid: errors.length === 0, errors, warnings };
+    };
+  `;
+}
+export function formatValidationResult(result) {
+  const lines = [];
+  if (result.valid)
+    lines.push("\u2713 All props are valid");
+  else {
+    lines.push("\u2717 Validation failed:");
+    for (const error of result.errors)
+      lines.push(`  \u2022 ${error.prop}: ${error.message}`);
+  }
+  if (result.warnings.length > 0) {
+    lines.push("");
+    lines.push("Warnings:");
+    for (const warning of result.warnings)
+      lines.push(`  \u26A0 ${warning.prop}: ${warning.message}`);
+  }
+  return lines.join(`
+`);
+}
+export function generateValidationErrorsHTML(result) {
+  if (result.valid && result.warnings.length === 0)
+    return "";
+  const errorItems = result.errors.map((e) => `
+    <div class="validation-error">
+      <strong>${e.prop}:</strong> ${e.message}
+    </div>
+  `).join(""), warningItems = result.warnings.map((w) => `
+    <div class="validation-warning">
+      <strong>${w.prop}:</strong> ${w.message}
+    </div>
+  `).join("");
+  return `
+    <div class="stx-validation-panel ${result.valid ? "warnings-only" : "has-errors"}">
+      ${errorItems}
+      ${warningItems}
+    </div>
+  `;
+}
+export function getValidationStyles() {
+  return `
+    .stx-validation-panel {
+      padding: 12px;
+      margin: 8px 0;
+      border-radius: 4px;
+      font-size: 13px;
+    }
+    .stx-validation-panel.has-errors {
+      background: #fee2e2;
+      border: 1px solid #ef4444;
+    }
+    .stx-validation-panel.warnings-only {
+      background: #fef3c7;
+      border: 1px solid #f59e0b;
+    }
+    .validation-error {
+      color: #dc2626;
+      margin-bottom: 4px;
+    }
+    .validation-warning {
+      color: #d97706;
+      margin-bottom: 4px;
+    }
+  `;
+}

package/dist/story/renderer.js

@@ -1,2 +1,209 @@
-// @bun
-import{hc as a,ic as b,jc as c,kc as d,lc as e,mc as f,nc as g}from"../chunk-7n8g0nfn.js";import"../chunk-1xz0w746.js";import"../chunk-m8448qby.js";import"../chunk-kx6eb6ma.js";import"../chunk-g1vt329s.js";import"../chunk-7074g241.js";import"../chunk-9cf97f9p.js";import"../chunk-6djzdes9.js";import"../chunk-v7f8jj15.js";import"../chunk-keawsbpn.js";import"../chunk-8b3z0zd5.js";import"../chunk-hbgxbgam.js";import"../chunk-ejh8fyak.js";import"../chunk-krqn0ddk.js";import"../chunk-y1k17c8b.js";import"../chunk-2j21d3ka.js";import"../chunk-frg705zq.js";import"../chunk-hjm2xab3.js";import"../chunk-07y6m5xx.js";import"../chunk-wazkqv7n.js";import"../chunk-x05nxhyv.js";import"../chunk-31dr4bys.js";import"../chunk-mgj88zeq.js";import"../chunk-m167kjhv.js";import"../chunk-3a4qsygv.js";import"../chunk-dqn9gyhb.js";import"../chunk-988dw6q3.js";import"../chunk-8qc1bsym.js";import"../chunk-xyg1r5w0.js";import"../chunk-7gd339hd.js";import"../chunk-4deg33rw.js";import"../chunk-pa9zb7ty.js";import"../chunk-a2g2qb2y.js";import"../chunk-h5jxydqq.js";import"../chunk-nhv099jv.js";import"../chunk-shv88d2d.js";import"../chunk-0dx4q6yq.js";import"../chunk-ek2w6zvy.js";import"../chunk-9wmq2272.js";import"../chunk-7dkz6z2s.js";import"../chunk-9ecv8aqj.js";import"../chunk-bdk6g1vj.js";import"../chunk-xqq1vxb6.js";import"../chunk-amaa1bev.js";import"../chunk-r5m9xtm7.js";import"../chunk-bs3gmfxz.js";import"../chunk-1zgsgk4b.js";import"../chunk-2jxbwnkz.js";import"../chunk-zen6ax1y.js";import"../chunk-yb1t2h8h.js";import"../chunk-fjk3x41y.js";import"../chunk-5shey2e4.js";import"../chunk-27zsyhrd.js";import"../chunk-7ed3tean.js";import"../chunk-8vtm0m84.js";import"../chunk-tzwtg722.js";import"../chunk-ah88wzbg.js";import"../chunk-v8j49spx.js";import"../chunk-tg2f1mzq.js";import"../chunk-n9dhs1dw.js";import"../chunk-rwrv9wbf.js";import"../chunk-wg9k6h8w.js";import"../chunk-9jtj77jx.js";import"../chunk-qygvvygy.js";import"../chunk-gz5fmp3q.js";import"../chunk-vjbefncc.js";import"../chunk-8xj7c3mf.js";import"../chunk-qvrbjpdc.js";import"../chunk-w3b6m427.js";import"../chunk-rz2ec6g7.js";import"../chunk-35faj94w.js";import"../chunk-djddhmcc.js";import"../chunk-knm8a8yx.js";import"../chunk-xv34zbp4.js";export{b as renderStoryVariant,a as renderStoryComponent,c as renderInlineTemplate,f as preloadComponents,e as getCacheStats,g as generatePreviewDocument,d as clearStoryCache};
+import fs from "node:fs";
+import { extractVariables } from "../utils.js";
+const componentCache = new Map;
+export async function renderStoryComponent(ctx, componentPath, options = {}) {
+  const startTime = performance.now(), errors = [];
+  try {
+    const stat = await fs.promises.stat(componentPath), cached = componentCache.get(componentPath);
+    let content;
+    if (cached && cached.mtime === stat.mtimeMs)
+      content = cached.content;
+    else {
+      content = await fs.promises.readFile(componentPath, "utf-8");
+      componentCache.set(componentPath, {
+        content,
+        mtime: stat.mtimeMs,
+        analyzed: null
+      });
+    }
+    const { processDirectives } = await import("../process.js"), propsContext = {}, scriptContent = extractScripts(content);
+    if (scriptContent)
+      try {
+        await extractVariables(scriptContent, propsContext, componentPath);
+      } catch (extractError) {
+        errors.push(`Warning: Could not extract script variables: ${extractError instanceof Error ? extractError.message : String(extractError)}`);
+      }
+    if (options.props)
+      Object.assign(propsContext, options.props);
+    let html = await processDirectives(content, propsContext, componentPath, {}, new Set);
+    const css = extractStyles(content), js = extractScripts(content);
+    html = stripTagsForPreview(html);
+    html = injectPropsIntoHtml(html, propsContext);
+    return {
+      html,
+      css,
+      js,
+      errors,
+      duration: performance.now() - startTime
+    };
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+    return {
+      html: `<div class="stx-render-error">${escapeHtml(errors[0])}</div>`,
+      css: "",
+      js: "",
+      errors,
+      duration: performance.now() - startTime
+    };
+  }
+}
+async function extractVariantsFromScript(componentPath) {
+  try {
+    const content = await fs.promises.readFile(componentPath, "utf-8"), scriptContent = extractScripts(content);
+    if (!scriptContent)
+      return null;
+    const context = {};
+    await extractVariables(scriptContent, context, componentPath);
+    if (Array.isArray(context.variants))
+      return context.variants;
+    return null;
+  } catch {
+    return null;
+  }
+}
+export async function renderStoryVariant(ctx, story, variantId, props) {
+  let variants = story.story?.variants;
+  if (!variants) {
+    const extractedVariants = await extractVariantsFromScript(story.path);
+    if (extractedVariants)
+      variants = extractedVariants;
+  }
+  if (!variants && variantId === "default")
+    return renderStoryComponent(ctx, story.path, { props: props || {} });
+  if (!variants)
+    return renderStoryComponent(ctx, story.path, { props: props || {} });
+  const variant = variants.find((v) => v.id === variantId);
+  if (!variant && variantId === "default")
+    return renderStoryComponent(ctx, story.path, { props: props || {} });
+  if (!variant)
+    return {
+      html: '<div class="stx-render-error">Variant not found</div>',
+      css: "",
+      js: "",
+      errors: [`Variant '${variantId}' not found`],
+      duration: 0
+    };
+  const mergedProps = { ...variant.state, ...props };
+  if (variant.source)
+    return renderInlineTemplate(ctx, variant.source, mergedProps);
+  return renderStoryComponent(ctx, story.path, { props: mergedProps });
+}
+export async function renderInlineTemplate(ctx, template, props = {}) {
+  const startTime = performance.now(), errors = [];
+  try {
+    const { processDirectives } = await import("../process.js"), context = { ...props }, scriptContent = extractScripts(template);
+    if (scriptContent)
+      try {
+        await extractVariables(scriptContent, context, "inline-template.stx");
+      } catch {}
+    let html = await processDirectives(template, context, "inline-template.stx", {}, new Set);
+    html = stripTagsForPreview(html);
+    html = injectPropsIntoHtml(html, context);
+    return {
+      html,
+      css: extractStyles(template),
+      js: extractScripts(template),
+      errors,
+      duration: performance.now() - startTime
+    };
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+    return {
+      html: `<div class="stx-render-error">${escapeHtml(errors[0])}</div>`,
+      css: "",
+      js: "",
+      errors,
+      duration: performance.now() - startTime
+    };
+  }
+}
+function extractStyles(content) {
+  const styles = [], styleRegex = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+  let match = styleRegex.exec(content);
+  while (match !== null) {
+    styles.push(match[1].trim());
+    match = styleRegex.exec(content);
+  }
+  return styles.join(`
+`);
+}
+function stripTagsForPreview(content) {
+  return content.replace(/<!--[\s\S]*?-->/g, "").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/^\s*\n/gm, "").trim();
+}
+function extractScripts(content) {
+  const scripts = [], scriptRegex = /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
+  let match = scriptRegex.exec(content);
+  while (match !== null) {
+    scripts.push(match[1].trim());
+    match = scriptRegex.exec(content);
+  }
+  return scripts.join(`
+`);
+}
+function injectPropsIntoHtml(html, props) {
+  const propsScript = `<script>window.__stxProps = ${JSON.stringify(props)};</script>`;
+  return html + propsScript;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+export function clearStoryCache() {
+  componentCache.clear();
+}
+export function getCacheStats() {
+  return {
+    size: componentCache.size,
+    entries: Array.from(componentCache.keys())
+  };
+}
+export async function preloadComponents(paths) {
+  let loaded = 0;
+  for (const componentPath of paths)
+    try {
+      const stat = await fs.promises.stat(componentPath), content = await fs.promises.readFile(componentPath, "utf-8");
+      componentCache.set(componentPath, {
+        content,
+        mtime: stat.mtimeMs,
+        analyzed: null
+      });
+      loaded++;
+    } catch {}
+  return loaded;
+}
+export function generatePreviewDocument(result, options = {}) {
+  const { title = "Preview", theme = "light", background = "#ffffff", crosswindCss = "" } = options;
+  return `<!DOCTYPE html>
+<html lang="en" class="${theme === "dark" ? "dark" : ""}">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      padding: 16px;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: ${background};
+    }
+    .stx-render-error {
+      padding: 16px;
+      background: #fee2e2;
+      border: 1px solid #ef4444;
+      border-radius: 4px;
+      color: #dc2626;
+      font-family: monospace;
+      white-space: pre-wrap;
+    }
+    ${crosswindCss}
+    ${result.css}
+  </style>
+</head>
+<body>
+  ${result.html}
+  <script>
+    ${result.js}
+  </script>
+</body>
+</html>`;
+}

package/dist/story/search-index.js

@@ -1,2 +1,106 @@
-// @bun
-import{H as a,I as b,J as c,K as d,L as e,M as f}from"../chunk-0dz85jrp.js";import"../chunk-xv34zbp4.js";export{e as searchIndex,b as saveSearchIndex,a as loadSearchIndex,d as isIndexStale,f as getOrBuildSearchIndex,c as buildPersistedSearchIndex};
+import fs from "node:fs";
+import path from "node:path";
+const INDEX_VERSION = 1, INDEX_FILE = ".stx/story/search-index.json";
+function getIndexPath(root) {
+  return path.join(root, INDEX_FILE);
+}
+export async function loadSearchIndex(ctx) {
+  const indexPath = getIndexPath(ctx.root);
+  try {
+    const content = await fs.promises.readFile(indexPath, "utf-8"), index = JSON.parse(content);
+    if (index.version !== INDEX_VERSION)
+      return null;
+    return index;
+  } catch {
+    return null;
+  }
+}
+export async function saveSearchIndex(ctx, entries) {
+  const indexPath = getIndexPath(ctx.root), indexDir = path.dirname(indexPath);
+  await fs.promises.mkdir(indexDir, { recursive: !0 });
+  const index = {
+    version: INDEX_VERSION,
+    created: Date.now(),
+    updated: Date.now(),
+    entries
+  };
+  await fs.promises.writeFile(indexPath, JSON.stringify(index, null, 2));
+}
+export function buildPersistedSearchIndex(storyFiles, components) {
+  const entries = [];
+  for (const file of storyFiles) {
+    const component = components.get(file.fileName), searchParts = [
+      file.fileName.toLowerCase(),
+      file.relativePath.toLowerCase()
+    ], props = [], tags = [];
+    if (component) {
+      if (component.description)
+        searchParts.push(component.description.toLowerCase());
+      for (const prop of component.props) {
+        props.push(prop.name);
+        searchParts.push(prop.name.toLowerCase());
+        if (prop.description)
+          searchParts.push(prop.description.toLowerCase());
+      }
+      for (const slot of component.slots)
+        tags.push(`slot:${slot.name}`);
+      for (const directive of component.directives || [])
+        tags.push(`directive:${directive.name}`);
+      for (const dep of component.dependencies)
+        tags.push(`uses:${dep}`);
+    }
+    entries.push({
+      id: file.id,
+      name: file.fileName,
+      path: file.relativePath,
+      searchText: searchParts.join(" "),
+      props,
+      tags,
+      mtime: Date.now()
+    });
+  }
+  return entries;
+}
+export async function isIndexStale(ctx, index) {
+  for (const entry of index.entries)
+    try {
+      const fullPath = path.join(ctx.root, entry.path);
+      if ((await fs.promises.stat(fullPath)).mtimeMs > entry.mtime)
+        return !0;
+    } catch {
+      return !0;
+    }
+  return !1;
+}
+export function searchIndex(index, query) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (terms.length === 0)
+    return index.entries;
+  return index.entries.map((entry) => {
+    let score = 0;
+    for (const term of terms)
+      if (entry.name.toLowerCase() === term)
+        score += 100;
+      else if (entry.name.toLowerCase().startsWith(term))
+        score += 50;
+      else if (entry.name.toLowerCase().includes(term))
+        score += 25;
+      else if (entry.props.some((p) => p.toLowerCase().includes(term)))
+        score += 15;
+      else if (entry.tags.some((t) => t.toLowerCase().includes(term)))
+        score += 10;
+      else if (entry.searchText.includes(term))
+        score += 5;
+    return { entry, score };
+  }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).map((s) => s.entry);
+}
+export async function getOrBuildSearchIndex(ctx, storyFiles, components, forceRebuild = !1) {
+  if (!forceRebuild) {
+    const cached = await loadSearchIndex(ctx);
+    if (cached && !await isIndexStale(ctx, cached))
+      return cached.entries;
+  }
+  const entries = buildPersistedSearchIndex(storyFiles, components);
+  saveSearchIndex(ctx, entries).catch(() => {});
+  return entries;
+}

package/dist/story/search.js

@@ -1,2 +1,140 @@
-// @bun
-import{Bb as a,Cb as b,Db as c,Eb as d,Fb as e,Gb as f,Hb as g,Ib as h}from"../chunk-0jd0pndq.js";import"../chunk-xv34zbp4.js";export{c as search,h as importSearchIndex,f as getSearchIndexSize,d as getRecentSearches,g as exportSearchIndex,e as clearSearchIndex,a as buildSearchIndex,b as buildComponentSearchIndex};
+let searchIndex = [];
+export function buildSearchIndex(ctx) {
+  searchIndex = [];
+  for (const file of ctx.storyFiles) {
+    searchIndex.push({
+      text: file.fileName.toLowerCase(),
+      original: file.fileName,
+      type: "story",
+      storyId: file.id
+    });
+    searchIndex.push({
+      text: file.relativePath.toLowerCase(),
+      original: file.relativePath,
+      type: "story",
+      storyId: file.id
+    });
+    if (file.story)
+      for (const variant of file.story.variants)
+        searchIndex.push({
+          text: variant.title.toLowerCase(),
+          original: variant.title,
+          type: "story",
+          storyId: file.id,
+          variantId: variant.id
+        });
+  }
+}
+export function buildComponentSearchIndex(components) {
+  for (const component of components) {
+    const storyId = component.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    searchIndex.push({
+      text: component.name.toLowerCase(),
+      original: component.name,
+      type: "component",
+      storyId
+    });
+    if (component.description)
+      searchIndex.push({
+        text: component.description.toLowerCase(),
+        original: component.description,
+        type: "component",
+        storyId
+      });
+    for (const prop of component.props) {
+      searchIndex.push({
+        text: prop.name.toLowerCase(),
+        original: prop.name,
+        type: "prop",
+        storyId,
+        meta: { propType: prop.type }
+      });
+      if (prop.description)
+        searchIndex.push({
+          text: prop.description.toLowerCase(),
+          original: prop.description,
+          type: "prop",
+          storyId,
+          meta: { propName: prop.name }
+        });
+    }
+    for (const slot of component.slots)
+      searchIndex.push({
+        text: slot.name.toLowerCase(),
+        original: slot.name,
+        type: "slot",
+        storyId
+      });
+    if (component.tags)
+      for (const tag of component.tags)
+        searchIndex.push({
+          text: tag.toLowerCase(),
+          original: tag,
+          type: "component",
+          storyId,
+          meta: { tag: !0 }
+        });
+  }
+}
+export function search(query, limit = 20) {
+  if (!query || query.length < 2)
+    return [];
+  const queryLower = query.toLowerCase(), results = [], seen = new Set;
+  for (const entry of searchIndex) {
+    const matchIndex = entry.text.indexOf(queryLower);
+    if (matchIndex === -1)
+      continue;
+    let score = 100;
+    if (entry.text === queryLower)
+      score += 50;
+    if (matchIndex === 0)
+      score += 30;
+    if (matchIndex === 0 || entry.text[matchIndex - 1] === " " || entry.text[matchIndex - 1] === "-")
+      score += 20;
+    if (entry.type === "story")
+      score += 10;
+    if (entry.type === "component")
+      score += 5;
+    score -= entry.text.length * 0.5;
+    const key = `${entry.storyId}-${entry.variantId || ""}-${entry.type}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    results.push({
+      type: entry.type,
+      title: entry.original,
+      storyId: entry.storyId,
+      variantId: entry.variantId,
+      score,
+      match: highlightMatch(entry.original, query)
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}
+function highlightMatch(text, query) {
+  const index = text.toLowerCase().indexOf(query.toLowerCase());
+  if (index === -1)
+    return text;
+  const before = text.slice(0, index), match = text.slice(index, index + query.length), after = text.slice(index + query.length);
+  return `${before}<mark>${match}</mark>${after}`;
+}
+export function getRecentSearches() {
+  return [];
+}
+export function clearSearchIndex() {
+  searchIndex = [];
+}
+export function getSearchIndexSize() {
+  return searchIndex.length;
+}
+export function exportSearchIndex() {
+  return JSON.stringify(searchIndex);
+}
+export function importSearchIndex(json) {
+  try {
+    searchIndex = JSON.parse(json);
+  } catch {
+    searchIndex = [];
+  }
+}