@thinkingos/vsl-sdk 0.4.4 → 1.1.0

package/dist/index.mjs

@@ -1,3 +1,594 @@
+// src/utils/idGenerator.ts
+var TYPE_ABBREVIATIONS = {
+  button: "btn",
+  input: "inp",
+  link: "link",
+  container: "cont",
+  image: "img",
+  select: "sel",
+  textarea: "txt",
+  heading: "h",
+  text: "txt",
+  file_input: "file",
+  modal: "modal",
+  tab: "tab",
+  dropdown_toggle: "dropdown",
+  footer: "footer",
+  scrollable_container: "scroll",
+  toolbar: "toolbar",
+  list: "list",
+  grid: "grid",
+  form_field: "form",
+  tab_bar: "tabs",
+  layout: "layout",
+  nav: "nav",
+  header: "header",
+  main: "main",
+  icon: "icon",
+  chart: "chart",
+  custom_widget: "widget",
+  unknown: "el"
+};
+var IdGenerator = class {
+  typeCounters = /* @__PURE__ */ new Map();
+  /**
+   * Generate ID for an element.
+   *
+   * @param elementId - Existing DOM id attribute (if present)
+   * @param vslType - VSL type of the element (for fallback abbreviation)
+   * @returns Generated ID string
+   */
+  generate(elementId2, vslType) {
+    if (elementId2 && elementId2.trim().length > 0) {
+      return elementId2;
+    }
+    const shortType = vslType ? TYPE_ABBREVIATIONS[vslType] || "el" : "el";
+    const count = (this.typeCounters.get(shortType) || 0) + 1;
+    this.typeCounters.set(shortType, count);
+    return `${shortType}_${count}`;
+  }
+  /** Reset counters (for testing or new snapshot). */
+  reset() {
+    this.typeCounters.clear();
+  }
+  /** Get current counter value for a type (for debugging). */
+  getCounter(type) {
+    if (type) {
+      return this.typeCounters.get(type) || 0;
+    }
+    let total = 0;
+    for (const count of this.typeCounters.values()) {
+      total += count;
+    }
+    return total;
+  }
+};
+function createIdGenerator() {
+  return new IdGenerator();
+}
+
+// src/security/promptInjectionFilter.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, appendFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/security/remotePatternsLoader.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+var DEFAULT_REMOTE_URL = "https://raw.githubusercontent.com/MaxZhadobin/visual-scene-language/vsl_mcp/patterns/latest.json";
+var DEFAULT_CACHE_PATH = join(homedir(), ".vsl", "cache", "remote-patterns.json");
+var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS = 5e3;
+var RemotePatternsLoader = class {
+  remoteUrl;
+  cachePath;
+  cacheTtlMs;
+  enabled;
+  timeoutMs;
+  constructor(options = {}) {
+    this.remoteUrl = options.remoteUrl ?? DEFAULT_REMOTE_URL;
+    this.cachePath = options.cachePath ?? DEFAULT_CACHE_PATH;
+    this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    this.enabled = options.enabled ?? true;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  /**
+   * Загружает remote patterns с fallback на кэш.
+   *
+   * Логика:
+   *  1. Если enabled === false — возвращаем empty
+   *  2. Проверяем кэш — если валиден (TTL не истёк), используем кэш
+   *  3. Пытаемся загрузить с remote URL
+   *  4. Если загрузка успешна — обновляем кэш, возвращаем remote patterns
+   *  5. Если загрузка не удалась — используем кэш (fallback)
+   *  6. Если кэша нет — возвращаем empty
+   */
+  async load() {
+    if (!this.enabled) {
+      return { patterns: [], source: "none", fallbackUsed: false };
+    }
+    const cachedData = this.readCache();
+    const cacheIsValid = this.isCacheValid(cachedData);
+    if (cacheIsValid) {
+      return {
+        patterns: cachedData.patterns,
+        source: "cache",
+        fallbackUsed: false
+      };
+    }
+    try {
+      const patterns = await this.fetchRemotePatterns();
+      this.writeCache(patterns);
+      return {
+        patterns,
+        source: "remote",
+        fallbackUsed: false
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (cachedData) {
+        return {
+          patterns: cachedData.patterns,
+          source: "cache",
+          fallbackUsed: true,
+          error: errorMessage
+        };
+      }
+      return {
+        patterns: [],
+        source: "none",
+        fallbackUsed: true,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Загружает паттерны с remote URL.
+   */
+  async fetchRemotePatterns() {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(this.remoteUrl, {
+        signal: controller.signal,
+        headers: {
+          "Accept": "application/json",
+          "User-Agent": "VSL-Patterns-Loader/1.0"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      let patternsArray;
+      if (Array.isArray(data)) {
+        patternsArray = data;
+      } else if (typeof data === "object" && data !== null && Array.isArray(data.patterns)) {
+        patternsArray = data.patterns;
+      } else {
+        throw new Error("Invalid patterns format: expected array or { patterns: [] }");
+      }
+      const patterns = [];
+      for (const item of patternsArray) {
+        if (this.isValidPattern(item)) {
+          patterns.push(item);
+        }
+      }
+      return patterns;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Проверяет валидность паттерна.
+   */
+  isValidPattern(item) {
+    if (typeof item !== "object" || item === null) return false;
+    const obj = item;
+    return typeof obj.id === "string" && typeof obj.pattern === "string" && typeof obj.type === "string" && (obj.type === "regex" || obj.type === "ml") && typeof obj.severity === "string" && ["low", "medium", "high", "critical"].includes(obj.severity) && typeof obj.action === "string" && ["strip", "log", "block"].includes(obj.action) && typeof obj.description === "string";
+  }
+  /**
+   * Читает кэш из файла.
+   */
+  readCache() {
+    if (!existsSync(this.cachePath)) {
+      return null;
+    }
+    try {
+      const content = readFileSync(this.cachePath, "utf-8");
+      const data = JSON.parse(content);
+      if (!data.metadata || !Array.isArray(data.patterns)) {
+        return null;
+      }
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Записывает паттерны в кэш.
+   */
+  writeCache(patterns) {
+    const cacheData = {
+      metadata: {
+        lastFetched: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceUrl: this.remoteUrl,
+        patternCount: patterns.length
+      },
+      patterns
+    };
+    try {
+      const cacheDir = dirname(this.cachePath);
+      if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, { recursive: true });
+      }
+      writeFileSync(this.cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
+    } catch (error) {
+      console.error(`[RemotePatternsLoader] Failed to write cache: ${error}`);
+    }
+  }
+  /**
+   * Проверяет валидность кэша (TTL не истёк).
+   */
+  isCacheValid(cachedData) {
+    if (!cachedData) return false;
+    try {
+      const lastFetched = new Date(cachedData.metadata.lastFetched).getTime();
+      const now = Date.now();
+      return now - lastFetched < this.cacheTtlMs;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Очищает кэш (для тестирования).
+   */
+  clearCache() {
+    try {
+      if (existsSync(this.cachePath)) {
+        writeFileSync(this.cachePath, "", "utf-8");
+      }
+    } catch (error) {
+      console.error(`[RemotePatternsLoader] Failed to clear cache: ${error}`);
+    }
+  }
+  /**
+   * Получает информацию о кэше (для диагностики).
+   */
+  getCacheInfo() {
+    const cachedData = this.readCache();
+    if (!cachedData) {
+      return { exists: false };
+    }
+    return {
+      exists: true,
+      lastFetched: cachedData.metadata.lastFetched,
+      patternCount: cachedData.metadata.patternCount
+    };
+  }
+  /**
+   * Получает URL для загрузки remote patterns.
+   */
+  getRemoteUrl() {
+    return this.remoteUrl;
+  }
+  /**
+   * Устанавливает URL для загрузки remote patterns.
+   */
+  setRemoteUrl(url) {
+    this.remoteUrl = url;
+  }
+};
+
+// src/security/promptInjectionFilter.ts
+var DEFAULT_LOG_DIR = join2(homedir2(), ".vsl", "logs");
+var DEFAULT_LOG_PATH = join2(DEFAULT_LOG_DIR, "security-audit.log");
+var DEFAULT_BUNDLED_PATTERNS_PATH = join2(__dirname, "..", "..", "patterns", "patterns_v1.json");
+var DEFAULT_REMOTE_PATTERNS_PATH = join2(homedir2(), ".vsl", "cache", "remote-patterns.json");
+var DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
+var DEFAULT_MAX_LOG_ENTRIES = 1e4;
+var PromptInjectionFilter = class {
+  enabled;
+  confidenceThreshold;
+  domainWhitelist;
+  patterns = [];
+  logPath;
+  maxLogEntries;
+  logEntries = [];
+  remoteLoader = null;
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? true;
+    this.confidenceThreshold = options.confidenceThreshold ?? DEFAULT_CONFIDENCE_THRESHOLD;
+    this.domainWhitelist = new Set(options.domainWhitelist ?? []);
+    this.logPath = options.logPath ?? DEFAULT_LOG_PATH;
+    this.maxLogEntries = options.maxLogEntries ?? DEFAULT_MAX_LOG_ENTRIES;
+    if (options.remoteLoader?.enabled !== false) {
+      this.remoteLoader = new RemotePatternsLoader({
+        remoteUrl: options.remoteLoader?.remoteUrl,
+        cachePath: options.remoteLoader?.cachePath ?? options.remotePatternsPath,
+        cacheTtlMs: options.remoteLoader?.cacheTtlMs,
+        enabled: options.remoteLoader?.enabled ?? true,
+        timeoutMs: options.remoteLoader?.timeoutMs
+      });
+    }
+    this.loadPatterns(options);
+    this.loadExistingLogs();
+  }
+  /**
+   * Загружает паттерны из всех источников (bundled, remote, custom).
+   */
+  loadPatterns(options) {
+    const allPatterns = [];
+    const bundledPath = options.bundledPatternsPath ?? DEFAULT_BUNDLED_PATTERNS_PATH;
+    if (existsSync2(bundledPath)) {
+      try {
+        const content = readFileSync2(bundledPath, "utf-8");
+        const bundled = JSON.parse(content);
+        allPatterns.push(...bundled);
+      } catch (error) {
+        console.error(`[PromptInjectionFilter] Failed to load bundled patterns: ${error}`);
+      }
+    }
+    const remotePath = options.remotePatternsPath ?? DEFAULT_REMOTE_PATTERNS_PATH;
+    if (existsSync2(remotePath)) {
+      try {
+        const content = readFileSync2(remotePath, "utf-8");
+        const remote = JSON.parse(content);
+        allPatterns.push(...remote);
+      } catch (error) {
+        console.error(`[PromptInjectionFilter] Failed to load remote patterns: ${error}`);
+      }
+    }
+    if (options.customPatterns && options.customPatterns.length > 0) {
+      allPatterns.push(...options.customPatterns);
+    }
+    this.patterns = allPatterns.filter((p) => p.type === "regex").map((p) => ({
+      ...p,
+      regex: new RegExp(p.pattern, "gi"),
+      // case-insensitive, global
+      confidenceThreshold: p.confidence ?? this.confidenceThreshold
+    }));
+  }
+  /**
+   * Асинхронно загружает remote patterns через RemotePatternsLoader.
+   * Вызывается опционально для обновления паттернов с CDN/GitHub.
+   *
+   * @returns Результат загрузки remote patterns
+   */
+  async loadRemotePatterns() {
+    if (!this.remoteLoader) {
+      return { patterns: 0, source: "none", fallbackUsed: false };
+    }
+    const result = await this.remoteLoader.load();
+    if (result.patterns.length > 0) {
+      const remoteCompiled = result.patterns.filter((p) => p.type === "regex").map((p) => ({
+        ...p,
+        regex: new RegExp(p.pattern, "gi"),
+        confidenceThreshold: p.confidence ?? this.confidenceThreshold
+      }));
+      this.patterns.push(...remoteCompiled);
+    }
+    return {
+      patterns: result.patterns.length,
+      source: result.source,
+      fallbackUsed: result.fallbackUsed,
+      error: result.error
+    };
+  }
+  /**
+   * Получает информацию о кэше remote patterns.
+   */
+  getRemoteCacheInfo() {
+    if (!this.remoteLoader) {
+      return { exists: false };
+    }
+    return this.remoteLoader.getCacheInfo();
+  }
+  /**
+   * Очищает кэш remote patterns.
+   */
+  clearRemoteCache() {
+    if (this.remoteLoader) {
+      this.remoteLoader.clearCache();
+    }
+  }
+  /**
+   * Загружает существующие логи из файла.
+   */
+  loadExistingLogs() {
+    if (!existsSync2(this.logPath)) {
+      return;
+    }
+    try {
+      const content = readFileSync2(this.logPath, "utf-8");
+      const lines = content.trim().split("\n").filter((line) => line.length > 0);
+      this.logEntries = lines.map((line) => JSON.parse(line));
+    } catch (error) {
+      console.error(`[PromptInjectionFilter] Failed to load existing logs: ${error}`);
+      this.logEntries = [];
+    }
+  }
+  /**
+   * Проверяет, находится ли URL в whitelist.
+   */
+  isWhitelisted(url) {
+    if (!url) return false;
+    try {
+      const hostname = new URL(url).hostname;
+      return this.domainWhitelist.has(hostname);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Сканирует текст на наличие инъекций.
+   *
+   * @param text — текст для сканирования
+   * @param url — URL страницы (для whitelist и логирования)
+   * @returns Результат сканирования с очищенным текстом и списком обнаружений
+   */
+  scan(text, url) {
+    const startTime = performance.now();
+    if (!this.enabled || this.isWhitelisted(url)) {
+      return {
+        cleanText: text,
+        detections: [],
+        blocked: false,
+        scanTimeMs: performance.now() - startTime
+      };
+    }
+    const detections = [];
+    let cleanText = text;
+    let blocked = false;
+    for (const pattern of this.patterns) {
+      pattern.regex.lastIndex = 0;
+      let match;
+      while ((match = pattern.regex.exec(text)) !== null) {
+        const matchedText = match[0];
+        const index = match.index;
+        const contextStart = Math.max(0, index - 50);
+        const contextEnd = Math.min(text.length, index + matchedText.length + 50);
+        const context = text.slice(contextStart, contextEnd);
+        const detection = {
+          patternId: pattern.id,
+          description: pattern.description,
+          severity: pattern.severity,
+          action: pattern.action,
+          matchedText,
+          index,
+          context
+        };
+        detections.push(detection);
+        this.logDetection(detection, url);
+        if (pattern.action === "block") {
+          blocked = true;
+          cleanText = "";
+          break;
+        } else if (pattern.action === "strip") {
+          cleanText = cleanText.replace(matchedText, "");
+        }
+        if (match.index === pattern.regex.lastIndex) {
+          pattern.regex.lastIndex++;
+        }
+      }
+    }
+    if (detections.some((d) => d.action === "strip")) {
+      cleanText = cleanText.replace(/\s+/g, " ").trim();
+    }
+    return {
+      cleanText,
+      detections,
+      blocked,
+      scanTimeMs: performance.now() - startTime
+    };
+  }
+  /**
+   * Логирует обнаружение в security audit trail.
+   */
+  logDetection(detection, url) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      url,
+      patternId: detection.patternId,
+      description: detection.description,
+      severity: detection.severity,
+      action: detection.action,
+      matchedText: detection.matchedText,
+      context: detection.context
+    };
+    this.logEntries.push(entry);
+    if (this.logEntries.length > this.maxLogEntries) {
+      this.logEntries = this.logEntries.slice(-this.maxLogEntries);
+    }
+    this.writeLogEntry(entry);
+  }
+  /**
+   * Записывает одну запись в лог-файл.
+   */
+  writeLogEntry(entry) {
+    try {
+      const logDir = join2(this.logPath, "..");
+      if (!existsSync2(logDir)) {
+        mkdirSync2(logDir, { recursive: true });
+      }
+      appendFileSync(this.logPath, JSON.stringify(entry) + "\n", "utf-8");
+    } catch (error) {
+      console.error(`[PromptInjectionFilter] Failed to write log entry: ${error}`);
+    }
+  }
+  /**
+   * Получает все логи (для аудита).
+   */
+  getLogs() {
+    return [...this.logEntries];
+  }
+  /**
+   * Очищает логи (для тестирования).
+   */
+  clearLogs() {
+    this.logEntries = [];
+    try {
+      if (existsSync2(this.logPath)) {
+        writeFileSync2(this.logPath, "", "utf-8");
+      }
+    } catch (error) {
+      console.error(`[PromptInjectionFilter] Failed to clear logs: ${error}`);
+    }
+  }
+  /**
+   * Добавляет custom pattern динамически.
+   */
+  addCustomPattern(pattern) {
+    if (pattern.type !== "regex") {
+      console.warn(`[PromptInjectionFilter] Only regex patterns are supported, skipping: ${pattern.id}`);
+      return;
+    }
+    const compiled = {
+      ...pattern,
+      regex: new RegExp(pattern.pattern, "gi"),
+      confidenceThreshold: pattern.confidence ?? this.confidenceThreshold
+    };
+    this.patterns.push(compiled);
+  }
+  /**
+   * Удаляет custom pattern по ID.
+   */
+  removePattern(patternId) {
+    const initialLength = this.patterns.length;
+    this.patterns = this.patterns.filter((p) => p.id !== patternId);
+    return this.patterns.length < initialLength;
+  }
+  /**
+   * Получает количество загруженных паттернов.
+   */
+  getPatternCount() {
+    return this.patterns.length;
+  }
+  /**
+   * Включает/выключает фильтр.
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Проверяет, включён ли фильтр.
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+};
+function createFilter(options) {
+  return new PromptInjectionFilter(options);
+}
+var globalFilter = null;
+function getGlobalFilter() {
+  if (!globalFilter) {
+    globalFilter = new PromptInjectionFilter();
+  }
+  return globalFilter;
+}
+
 // src/capture/domExtractor.ts
 var NON_RENDERABLE_TAGS = /* @__PURE__ */ new Set([
   "script",
@@ -29,6 +620,16 @@ function ownText(el) {
   }
   return raw.replace(/\s+/g, " ").trim();
 }
+function filteredOwnText(el, url) {
+  const raw = ownText(el);
+  if (!raw) return raw;
+  const filter = getGlobalFilter();
+  if (!filter.isEnabled()) {
+    return raw;
+  }
+  const result = filter.scan(raw, url);
+  return result.cleanText;
+}
 function extractAttributes(el) {
   const attributes = {};
   for (const attr of Array.from(el.attributes)) {
@@ -73,7 +674,7 @@ function toRect(rect) {
 function hasZeroBox(rect) {
   return rect.width <= 0 || rect.height <= 0;
 }
-function collectVisibleChildren(parent, parentPath) {
+function collectVisibleChildren(parent, parentPath, url) {
   const result = [];
   Array.from(parent.children).forEach((child, index) => {
     const path = [...parentPath, index];
@@ -83,17 +684,17 @@ function collectVisibleChildren(parent, parentPath) {
     }
     const rect = toRect(child.getBoundingClientRect());
     if (isVisibilityHidden(child) || hasZeroBox(rect)) {
-      result.push(...collectVisibleChildren(child, path));
+      result.push(...collectVisibleChildren(child, path, url));
       return;
     }
     result.push({
       tag,
       indexPath: path,
       rect,
-      text: ownText(child) || null,
+      text: filteredOwnText(child, url) || null,
       attributes: extractAttributes(child),
       css: captureCss(child),
-      children: collectVisibleChildren(child, path)
+      children: collectVisibleChildren(child, path, url)
     });
   });
   return result;
@@ -105,8 +706,8 @@ function defaultRoot() {
   }
   return body;
 }
-function extractDomTree(root = defaultRoot()) {
-  return collectVisibleChildren(root, []);
+function extractDomTree(root = defaultRoot(), url) {
+  return collectVisibleChildren(root, [], url);
 }
 
 // src/segmentation/level1.ts
@@ -131,7 +732,12 @@ var ARIA_ROLE_TYPE_MAP = {
   button: "button",
   dialog: "modal",
   tab: "tab",
-  tabpanel: "container"
+  tabpanel: "container",
+  combobox: "input",
+  listbox: "select",
+  searchbox: "input",
+  spinbutton: "input",
+  slider: "input"
 };
 function resolveAriaRoleType(role) {
   if (!role) return null;
@@ -314,7 +920,7 @@ var INTERACTIVE_ATTRS = [
 ];
 function relative(value, dimension) {
   if (dimension <= 0) return 0;
-  return Math.round(value / dimension * 1e4) / 1e4;
+  return Math.round(value / dimension * 100) / 100;
 }
 function defaultActions(t, st, attributes) {
   if (st === "disabled") return void 0;
@@ -382,10 +988,10 @@ function extractVisualStyles(css) {
   }
   return hasContent ? style : void 0;
 }
-function toVslObject(el, viewport, includedChildren, textBlocks, counter) {
+function toVslObject(el, viewport, includedChildren, textBlocks, counter, idGenerator) {
   const t = el.t ?? "container";
   const object = {
-    id: `${el.tag}_${el.indexPath.join("_")}`,
+    id: idGenerator.generate(el.attributes["id"], t),
     t,
     p: [relative(el.rect.x, viewport.width), relative(el.rect.y, viewport.height)],
     s: [Math.round(el.rect.width), Math.round(el.rect.height)]
@@ -419,12 +1025,12 @@ function toVslObject(el, viewport, includedChildren, textBlocks, counter) {
   }
   return object;
 }
-function convert(el, viewport, textBlocks, counter) {
-  const includedChildren = el.ch.map((child) => convert(child, viewport, textBlocks, counter)).filter((obj) => obj !== null);
-  if (el.t !== null) return toVslObject(el, viewport, includedChildren, textBlocks, counter);
+function convert(el, viewport, textBlocks, counter, idGenerator) {
+  const includedChildren = el.ch.map((child) => convert(child, viewport, textBlocks, counter, idGenerator)).filter((obj) => obj !== null);
+  if (el.t !== null) return toVslObject(el, viewport, includedChildren, textBlocks, counter, idGenerator);
   const score = baseSemanticScore(el) + (includedChildren.length > 0 ? 1 : 0);
   if (score >= 3 || includedChildren.length > 0) {
-    return toVslObject(el, viewport, includedChildren, textBlocks, counter);
+    return toVslObject(el, viewport, includedChildren, textBlocks, counter, idGenerator);
   }
   return null;
 }
@@ -473,7 +1079,8 @@ function buildVslDocument(elements, options = {}) {
   };
   const textBlocks = /* @__PURE__ */ new Map();
   const counter = { value: 0 };
-  const objects = elements.map((el) => convert(el, viewport, textBlocks, counter)).filter((obj) => obj !== null);
+  const idGenerator = new IdGenerator();
+  const objects = elements.map((el) => convert(el, viewport, textBlocks, counter, idGenerator)).filter((obj) => obj !== null);
   const vslDocument = {
     vsl_version: VSL_VERSION,
     canvas: buildCanvas(options, viewport),
@@ -1932,10 +2539,14 @@ export {
   ActionExecutionError,
   AlibabaAdapter,
   AnthropicAdapter,
+  IdGenerator,
   LEVEL1_TAG_MAP,
   LlmError,
   LlmValidationError,
   OpenAIAdapter,
+  PromptInjectionFilter,
+  RemotePatternsLoader,
+  TYPE_ABBREVIATIONS,
   VALID_ACTIONS,
   VSL_SDK_VERSION,
   VSL_VERSION,
@@ -1948,9 +2559,12 @@ export {
   computeContentHash,
   computeCoordHash,
   createCacheStore,
+  createFilter,
+  createIdGenerator,
   diffVslDocuments,
   executeAction,
   extractDomTree,
+  getGlobalFilter,
   isAriaHidden,
   isVslDiff,
   ownText,