@thinkingos/vsl-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1912 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ACTION_TOOL_DESCRIPTION: () => ACTION_TOOL_DESCRIPTION,
+  ACTION_TOOL_NAME: () => ACTION_TOOL_NAME,
+  ACTION_TOOL_SCHEMA: () => ACTION_TOOL_SCHEMA,
+  ARIA_ROLE_TYPE_MAP: () => ARIA_ROLE_TYPE_MAP,
+  ActionExecutionError: () => ActionExecutionError,
+  AlibabaAdapter: () => AlibabaAdapter,
+  AnthropicAdapter: () => AnthropicAdapter,
+  LEVEL1_TAG_MAP: () => LEVEL1_TAG_MAP,
+  LlmError: () => LlmError,
+  LlmValidationError: () => LlmValidationError,
+  OpenAIAdapter: () => OpenAIAdapter,
+  VALID_ACTIONS: () => VALID_ACTIONS,
+  VSL_SDK_VERSION: () => VSL_SDK_VERSION,
+  VSL_VERSION: () => VSL_VERSION,
+  VslSnapshotSession: () => VslSnapshotSession,
+  attachMutationObserver: () => attachMutationObserver,
+  buildSystemPrompt: () => buildSystemPrompt,
+  buildUserPrompt: () => buildUserPrompt,
+  buildVslDocument: () => buildVslDocument,
+  collectIds: () => collectIds,
+  computeContentHash: () => computeContentHash,
+  computeCoordHash: () => computeCoordHash,
+  createCacheStore: () => createCacheStore,
+  diffVslDocuments: () => diffVslDocuments,
+  executeAction: () => executeAction,
+  extractDomTree: () => extractDomTree,
+  isAriaHidden: () => isAriaHidden,
+  isVslDiff: () => isVslDiff,
+  ownText: () => ownText,
+  resolveAriaRoleType: () => resolveAriaRoleType,
+  resolveLevel1Type: () => resolveLevel1Type,
+  resolveSt: () => resolveSt,
+  resolveTarget: () => resolveTarget,
+  retryWithBackoff: () => retryWithBackoff,
+  segmentTree: () => segmentTree,
+  validateAction: () => validateAction
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/capture/domExtractor.ts
+var NON_RENDERABLE_TAGS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "link",
+  "meta",
+  "noscript",
+  "template",
+  "head",
+  "title",
+  "base"
+]);
+function viewOf(el) {
+  return el.ownerDocument.defaultView;
+}
+function isDisplayNone(el) {
+  return viewOf(el)?.getComputedStyle(el).display === "none";
+}
+function isVisibilityHidden(el) {
+  return viewOf(el)?.getComputedStyle(el).visibility === "hidden";
+}
+var TEXT_NODE_TYPE = 3;
+function ownText(el) {
+  let raw = "";
+  for (const node of Array.from(el.childNodes)) {
+    if (node.nodeType === TEXT_NODE_TYPE) {
+      raw += node.textContent ?? "";
+    }
+  }
+  return raw.replace(/\s+/g, " ").trim();
+}
+function extractAttributes(el) {
+  const attributes = {};
+  for (const attr of Array.from(el.attributes)) {
+    attributes[attr.name] = attr.value;
+  }
+  return attributes;
+}
+var CSS_PROPERTIES = [
+  ["cursor", "cursor"],
+  ["position", "position"],
+  ["top", "top"],
+  ["bottom", "bottom"],
+  ["display", "display"],
+  ["gap", "gap"],
+  ["fontWeight", "font-weight"],
+  ["fontSize", "font-size"],
+  ["opacity", "opacity"],
+  ["pointerEvents", "pointer-events"],
+  ["overflow", "overflow"],
+  ["height", "height"]
+];
+function captureCss(el) {
+  const view = viewOf(el);
+  if (view === null) return {};
+  const style = view.getComputedStyle(el);
+  const css = {};
+  for (const [key, property] of CSS_PROPERTIES) {
+    const value = style.getPropertyValue(property);
+    if (value !== "") css[key] = value;
+  }
+  return css;
+}
+function toRect(rect) {
+  return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+}
+function hasZeroBox(rect) {
+  return rect.width <= 0 || rect.height <= 0;
+}
+function collectVisibleChildren(parent, parentPath) {
+  const result = [];
+  Array.from(parent.children).forEach((child, index) => {
+    const path = [...parentPath, index];
+    const tag = child.tagName.toLowerCase();
+    if (NON_RENDERABLE_TAGS.has(tag) || isDisplayNone(child)) {
+      return;
+    }
+    const rect = toRect(child.getBoundingClientRect());
+    if (isVisibilityHidden(child) || hasZeroBox(rect)) {
+      result.push(...collectVisibleChildren(child, path));
+      return;
+    }
+    result.push({
+      tag,
+      indexPath: path,
+      rect,
+      text: ownText(child) || null,
+      attributes: extractAttributes(child),
+      css: captureCss(child),
+      children: collectVisibleChildren(child, path)
+    });
+  });
+  return result;
+}
+function defaultRoot() {
+  const body = document.body;
+  if (!body) {
+    throw new Error("extractDomTree: document.body is null \u2014 call after the DOM is loaded");
+  }
+  return body;
+}
+function extractDomTree(root = defaultRoot()) {
+  return collectVisibleChildren(root, []);
+}
+
+// src/segmentation/level1.ts
+var LEVEL1_TAG_MAP = {
+  button: "button",
+  input: "input",
+  a: "link",
+  nav: "nav",
+  header: "header",
+  main: "main",
+  section: "container",
+  img: "image",
+  select: "select",
+  textarea: "textarea"
+};
+function resolveLevel1Type(tag) {
+  return LEVEL1_TAG_MAP[tag.toLowerCase()] ?? null;
+}
+
+// src/segmentation/level2.ts
+var ARIA_ROLE_TYPE_MAP = {
+  button: "button",
+  dialog: "modal",
+  tab: "tab",
+  tabpanel: "container"
+};
+function resolveAriaRoleType(role) {
+  if (!role) return null;
+  return ARIA_ROLE_TYPE_MAP[role.toLowerCase()] ?? null;
+}
+var TRUE = "true";
+function resolveSt(attributes) {
+  if (attributes["aria-pressed"] === TRUE) return "checked";
+  if (attributes["aria-expanded"] === TRUE) return "expanded";
+  if (attributes["aria-disabled"] === TRUE) return "disabled";
+  return null;
+}
+
+// src/segmentation/level3.ts
+function px(value) {
+  return value === void 0 ? Number.NaN : Number.parseFloat(value);
+}
+function resolveLevel3Type(css, attributes) {
+  if (css === void 0) return null;
+  if (css.cursor === "pointer" && attributes["onclick"] !== void 0) return "button";
+  if (css.display === "flex" && px(css.gap) > 0) return "container";
+  const isBold = css.fontWeight === "bold" || px(css.fontWeight) >= 700;
+  if (isBold && px(css.fontSize) > 20) return "heading";
+  if (css.position === "fixed" && px(css.top) === 0) return "header";
+  if (css.position === "fixed" && px(css.bottom) === 0) return "footer";
+  if (css.overflow === "hidden" && px(css.height) > 200) return "scrollable_container";
+  return null;
+}
+function isPointerInvisible(css) {
+  if (css === void 0) return false;
+  return px(css.opacity) === 0 && css.pointerEvents === "none";
+}
+
+// src/segmentation/level4.ts
+var EPS = 2;
+var bottomOf = (r) => r.y + r.height;
+var rightOf = (r) => r.x + r.width;
+function sameRow(a, b) {
+  const overlap = Math.min(bottomOf(a), bottomOf(b)) - Math.max(a.y, b.y);
+  return overlap > 0.5 * Math.min(a.height, b.height);
+}
+function sameColumn(a, b) {
+  const overlap = Math.min(rightOf(a), rightOf(b)) - Math.max(a.x, b.x);
+  return overlap > 0.5 * Math.min(a.width, b.width);
+}
+var eq = (a, b) => Math.abs(a - b) <= EPS;
+var sameHeight = (a, b) => eq(a.height, b.height);
+var sameWidth = (a, b) => eq(a.width, b.width);
+function isToolbarRow(children) {
+  const buttons = children.filter((c) => c.t === "button");
+  const first = buttons[0];
+  if (buttons.length < 3 || first === void 0) return false;
+  return buttons.slice(1).every((b) => sameRow(first.rect, b.rect) && sameHeight(first.rect, b.rect));
+}
+function verticallyStacked(children) {
+  const sorted = [...children].sort((a, b) => a.rect.y - b.rect.y);
+  for (let i = 1; i < sorted.length; i += 1) {
+    if (sorted[i].rect.y < bottomOf(sorted[i - 1].rect) - EPS) return false;
+  }
+  return true;
+}
+function isVerticalList(children) {
+  const first = children[0];
+  if (children.length < 3 || first === void 0) return false;
+  return children.slice(1).every((c) => sameWidth(first.rect, c.rect) && sameColumn(first.rect, c.rect)) && verticallyStacked(children);
+}
+function bandCount(values, eps) {
+  const sorted = [...values].sort((a, b) => a - b);
+  let count = 1;
+  let anchor = sorted[0];
+  for (const value of sorted.slice(1)) {
+    if (value - anchor > eps) {
+      count += 1;
+      anchor = value;
+    }
+  }
+  return count;
+}
+function isGrid(children) {
+  const first = children[0];
+  if (children.length < 4 || first === void 0) return false;
+  const sameSize = children.slice(1).every((c) => sameWidth(first.rect, c.rect) && sameHeight(first.rect, c.rect));
+  if (!sameSize) return false;
+  return bandCount(children.map((c) => c.rect.y), first.rect.height + EPS) >= 2 && bandCount(children.map((c) => c.rect.x), first.rect.width + EPS) >= 2;
+}
+function adjacent(a, b) {
+  const gapX = Math.max(a.x, b.x) - Math.min(rightOf(a), rightOf(b));
+  const gapY = Math.max(a.y, b.y) - Math.min(bottomOf(a), bottomOf(b));
+  return sameRow(a, b) && gapX <= 8 * EPS || sameColumn(a, b) && gapY <= 8 * EPS;
+}
+function hasLabelNextToInput(children) {
+  return children.some((input) => {
+    if (input.t !== "input") return false;
+    return children.some((label) => {
+      if (label === input) return false;
+      if ((label.txt ?? "").length === 0) return false;
+      return adjacent(label.rect, input.rect);
+    });
+  });
+}
+function isTabBarRow(children) {
+  const tabs = children.filter((c) => c.attributes?.["role"] === "tab");
+  const first = tabs[0];
+  if (tabs.length < 2 || first === void 0) return false;
+  return tabs.slice(1).every((t) => sameRow(first.rect, t.rect));
+}
+function isSidebarSplit(children, parent) {
+  if (children.length !== 2) return false;
+  const sorted = [...children].sort((a, b) => a.rect.x - b.rect.x);
+  const left = sorted[0];
+  const right = sorted[1];
+  if (left === void 0 || right === void 0) return false;
+  return left.rect.width < parent.width / 3 && right.rect.width > parent.width / 2 && rightOf(left.rect) <= right.rect.x + EPS && sameRow(left.rect, right.rect);
+}
+function resolveLevel4Type(el) {
+  const children = el.ch ?? [];
+  if (children.length === 0) return null;
+  if (isToolbarRow(children)) return "toolbar";
+  if (isVerticalList(children)) return "list";
+  if (isGrid(children)) return "grid";
+  if (hasLabelNextToInput(children)) return "form_field";
+  if (isTabBarRow(children)) return "tab_bar";
+  if (isSidebarSplit(children, el.rect)) return "layout";
+  return null;
+}
+
+// src/segmentation/segmenter.ts
+function isAriaHidden(attributes) {
+  return attributes["aria-hidden"] === "true";
+}
+function segmentOne(el) {
+  const { attributes } = el;
+  return {
+    tag: el.tag,
+    indexPath: el.indexPath,
+    rect: el.rect,
+    attributes,
+    t: resolveLevel1Type(el.tag) ?? resolveAriaRoleType(attributes["role"]) ?? resolveLevel3Type(el.css, attributes),
+    txt: attributes["aria-label"] ?? el.text,
+    st: resolveSt(attributes),
+    ch: []
+  };
+}
+function segmentTree(elements) {
+  const result = [];
+  for (const el of elements) {
+    if (isAriaHidden(el.attributes)) continue;
+    if (isPointerInvisible(el.css)) continue;
+    const segmented = segmentOne(el);
+    segmented.ch = segmentTree(el.children);
+    if (segmented.t === null) {
+      segmented.t = resolveLevel4Type(segmented);
+    }
+    result.push(segmented);
+  }
+  return result;
+}
+
+// src/types/vsl.ts
+var VSL_VERSION = "1.0.0";
+
+// src/builder/vslBuilder.ts
+var LAZY_TEXT_THRESHOLD = 200;
+var LAZY_TEXT_PREVIEW_LENGTH = 50;
+var INTERACTIVE_ATTRS = [
+  "onclick",
+  "onmousedown",
+  "ontouchstart",
+  "tabindex",
+  "contenteditable"
+];
+function relative(value, dimension) {
+  if (dimension <= 0) return 0;
+  return Math.round(value / dimension * 1e4) / 1e4;
+}
+function defaultActions(t, st, attributes) {
+  if (st === "disabled") return void 0;
+  switch (t) {
+    case "button":
+    case "link":
+    case "tab":
+      return ["click"];
+    case "modal":
+      return ["close"];
+    case "input": {
+      const type = attributes["type"];
+      return type === "checkbox" || type === "radio" ? ["click", "check", "uncheck"] : ["click", "type", "clear"];
+    }
+    case "select":
+      return ["click", "select"];
+    case "textarea":
+      return ["click", "type", "clear"];
+    default:
+      return void 0;
+  }
+}
+function baseSemanticScore(el) {
+  let score = 0;
+  if (el.attributes["role"] !== void 0) score += 3;
+  if (el.attributes["aria-label"] !== void 0) score += 2;
+  if (INTERACTIVE_ATTRS.some((attr) => el.attributes[attr] !== void 0)) score += 2;
+  if (el.txt) score += 1;
+  return score;
+}
+function toVslObject(el, viewport, includedChildren, textBlocks, counter) {
+  const t = el.t ?? "container";
+  const object = {
+    id: `${el.tag}_${el.indexPath.join("_")}`,
+    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)]
+  };
+  const role = el.attributes["role"];
+  if (role !== void 0) object.r = role;
+  if (el.st) object.st = el.st;
+  if (el.txt) {
+    if (el.txt.length > LAZY_TEXT_THRESHOLD) {
+      object.txt_preview = el.txt.slice(0, LAZY_TEXT_PREVIEW_LENGTH) + "\u2026";
+      const refId = `tb_${String(counter.value++).padStart(3, "0")}`;
+      object.txt_ref = refId;
+      textBlocks.set(refId, el.txt);
+    } else {
+      object.txt = el.txt;
+    }
+  }
+  const act = defaultActions(t, el.st, el.attributes);
+  if (act !== void 0) object.act = act;
+  if (includedChildren.length > 0) object.ch = includedChildren;
+  if (el.vf !== void 0) object.vf = el.vf;
+  if (el.vf_meta !== void 0) object.vf_meta = el.vf_meta;
+  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);
+  const score = baseSemanticScore(el) + (includedChildren.length > 0 ? 1 : 0);
+  if (score >= 3 || includedChildren.length > 0) {
+    return toVslObject(el, viewport, includedChildren, textBlocks, counter);
+  }
+  return null;
+}
+function isIncludedInVsl(el) {
+  if (el.t !== null) return true;
+  const includedChildren = el.ch.filter(isIncludedInVsl).length;
+  const score = baseSemanticScore(el) + (includedChildren > 0 ? 1 : 0);
+  return score >= 3 || includedChildren > 0;
+}
+function buildCanvas(options, viewport) {
+  const url = options.url ?? window.location.href;
+  const title = options.title ?? document.title;
+  return {
+    viewport: { ...viewport, unit: "px" },
+    background: options.background ?? "#ffffff",
+    scale: 1,
+    orientation: viewport.width >= viewport.height ? "landscape" : "portrait",
+    timestamp: options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...url ? { url } : {},
+    ...title ? { title } : {}
+  };
+}
+function collectVisualFragments(objects) {
+  const map = {};
+  const visit = (list) => {
+    for (const object of list) {
+      if (object.vf !== void 0 && object.vf_meta !== void 0) {
+        map[object.vf] = {
+          type: object.vf_meta.type,
+          format: object.vf_meta.format ?? "webp",
+          size: object.vf_meta.size ?? [0, 0],
+          hash: object.vf_meta.hash,
+          cached_at: object.vf_meta.cached_at
+        };
+      }
+      visit(object.ch ?? []);
+    }
+  };
+  visit(objects);
+  return Object.keys(map).length > 0 ? map : void 0;
+}
+function buildVslDocument(elements, options = {}) {
+  const viewport = {
+    width: options.viewport?.width ?? window.innerWidth,
+    height: options.viewport?.height ?? window.innerHeight
+  };
+  const textBlocks = /* @__PURE__ */ new Map();
+  const counter = { value: 0 };
+  const objects = elements.map((el) => convert(el, viewport, textBlocks, counter)).filter((obj) => obj !== null);
+  const vslDocument = {
+    vsl_version: VSL_VERSION,
+    canvas: buildCanvas(options, viewport),
+    objects
+  };
+  const visualFragments = collectVisualFragments(objects);
+  if (visualFragments !== void 0) vslDocument.visual_fragments = visualFragments;
+  if (textBlocks.size > 0) vslDocument.text_blocks = Object.fromEntries(textBlocks);
+  return vslDocument;
+}
+
+// src/cache/cacheStore.ts
+var import_node_crypto = require("crypto");
+function sha256(payload) {
+  return (0, import_node_crypto.createHash)("sha256").update(payload).digest("hex");
+}
+function computeContentHash(object) {
+  const payload = { t: object.t };
+  if (object.r !== void 0) payload.r = object.r;
+  if (object.st !== void 0) payload.st = object.st;
+  if (object.txt !== void 0) payload.txt = object.txt;
+  if (object.act !== void 0) payload.act = object.act;
+  return sha256(JSON.stringify(payload));
+}
+function computeCoordHash(object) {
+  return sha256(JSON.stringify({ p: object.p, s: object.s }));
+}
+function createCacheStore() {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    set(id, object) {
+      entries.set(id, {
+        object,
+        contentHash: computeContentHash(object),
+        coordHash: computeCoordHash(object)
+      });
+    },
+    get(id) {
+      return entries.get(id);
+    },
+    has(id) {
+      return entries.has(id);
+    },
+    invalidate(id) {
+      entries.delete(id);
+    },
+    invalidateBySelector(selector) {
+      if (selector === "*") {
+        entries.clear();
+        return;
+      }
+      if (entries.has(selector)) {
+        entries.delete(selector);
+        return;
+      }
+      const prefix = `${selector}_`;
+      for (const id of entries.keys()) {
+        if (id.startsWith(prefix)) entries.delete(id);
+      }
+    },
+    invalidateCoordinates() {
+      for (const [id, entry] of entries) {
+        entries.set(id, { ...entry, coordHash: "" });
+      }
+    },
+    clear() {
+      entries.clear();
+    },
+    keys() {
+      return [...entries.keys()];
+    },
+    get size() {
+      return entries.size;
+    }
+  };
+}
+
+// src/cache/invalidation.ts
+function elementId(el, root) {
+  const indexPath = [];
+  let current = el;
+  while (current !== null && current !== root) {
+    const parent = current.parentElement;
+    if (parent === null) return null;
+    indexPath.unshift(Array.from(parent.children).indexOf(current));
+    current = parent;
+  }
+  if (current !== root || indexPath.length === 0) return null;
+  return `${el.tagName.toLowerCase()}_${indexPath.join("_")}`;
+}
+function invalidateMutationTarget(node, root, store) {
+  const start = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
+  if (start === null || start === root || !root.contains(start)) return;
+  let current = start;
+  while (current !== null && current !== root) {
+    const id = elementId(current, root);
+    if (id !== null && store.has(id)) {
+      store.invalidate(id);
+      return;
+    }
+    current = current.parentElement;
+  }
+}
+function attachMutationObserver(root, store) {
+  const observer = new MutationObserver((records) => {
+    for (const record of records) {
+      invalidateMutationTarget(record.target, root, store);
+    }
+  });
+  observer.observe(root, {
+    childList: true,
+    attributes: true,
+    characterData: true,
+    subtree: true
+  });
+  return { observer, disconnect: () => observer.disconnect() };
+}
+
+// src/diff/diffEngine.ts
+function flatten(objects, map) {
+  for (const object of objects) {
+    map.set(object.id, object);
+    flatten(object.ch ?? [], map);
+  }
+}
+function objectsEqual(a, b) {
+  return computeContentHash(a) === computeContentHash(b) && computeCoordHash(a) === computeCoordHash(b);
+}
+function tuple2Equal(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+function stringArrayEqual(a, b) {
+  if (a === void 0 || b === void 0) return a === b;
+  return a.length === b.length && a.every((value, i) => value === b[i]);
+}
+function buildModified(prev, next) {
+  const result = { id: next.id };
+  if (prev.t !== next.t) result.t = next.t;
+  if (prev.r !== next.r) result.r = next.r ?? null;
+  if (!tuple2Equal(prev.p, next.p)) result.p = next.p;
+  if (!tuple2Equal(prev.s, next.s)) result.s = next.s;
+  if (prev.st !== next.st) result.st = next.st ?? null;
+  if (prev.txt !== next.txt) result.txt = next.txt ?? null;
+  if (!stringArrayEqual(prev.act, next.act)) result.act = next.act ?? null;
+  return result;
+}
+function diffVslDocuments(prev, next, options) {
+  const prevFlat = /* @__PURE__ */ new Map();
+  const nextFlat = /* @__PURE__ */ new Map();
+  flatten(prev.objects, prevFlat);
+  flatten(next.objects, nextFlat);
+  const added = [];
+  const modified = [];
+  const unchangedRefs = [];
+  const walk = (objects, insideAdded) => {
+    for (const nextObject of objects) {
+      if (insideAdded) {
+        walk(nextObject.ch ?? [], true);
+        continue;
+      }
+      const prevObject = prevFlat.get(nextObject.id);
+      if (prevObject === void 0) {
+        added.push(nextObject);
+        walk(nextObject.ch ?? [], true);
+      } else if (objectsEqual(prevObject, nextObject)) {
+        unchangedRefs.push(nextObject.id);
+        walk(nextObject.ch ?? [], false);
+      } else {
+        modified.push(buildModified(prevObject, nextObject));
+        walk(nextObject.ch ?? [], false);
+      }
+    }
+  };
+  walk(next.objects, false);
+  const removed = [];
+  for (const id of prevFlat.keys()) {
+    if (!nextFlat.has(id)) removed.push({ id });
+  }
+  return {
+    diff_version: options.diffVersion,
+    base_version: options.baseVersion,
+    timestamp: options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    changes: { added, modified, removed, unchanged_refs: unchangedRefs }
+  };
+}
+
+// src/vision/enrichWithVision.ts
+function collectCandidates(elements) {
+  const candidates = [];
+  const visit = (element) => {
+    if (element.t === null && !isIncludedInVsl(element)) candidates.push(element);
+    for (const child of element.ch) {
+      visit(child);
+    }
+  };
+  for (const element of elements) visit(element);
+  return candidates;
+}
+function buildHint(element) {
+  return element.txt === null ? `tag=${element.tag}` : `tag=${element.tag}; text: ${element.txt}`;
+}
+async function enrichWithVision(elements, deps) {
+  const fragments = /* @__PURE__ */ new Map();
+  let enrichedCount = 0;
+  let failedCount = 0;
+  for (const element of collectCandidates(elements)) {
+    let extraction;
+    try {
+      extraction = await deps.extractor.extract(element.rect);
+    } catch {
+      failedCount += 1;
+      continue;
+    }
+    if (extraction === null) continue;
+    const { entry } = extraction;
+    let classification = entry.classification;
+    try {
+      if (classification === void 0) {
+        classification = await deps.classifier.classify(entry.data, buildHint(element));
+        entry.classification = classification;
+      }
+    } catch {
+      failedCount += 1;
+      continue;
+    }
+    element.t = classification.type;
+    element.vf = entry.vfId;
+    element.vf_meta = {
+      type: classification.type,
+      format: entry.meta.format,
+      size: entry.meta.size,
+      hash: entry.meta.hash,
+      cached_at: entry.meta.cached_at
+    };
+    fragments.set(entry.vfId, entry.data);
+    enrichedCount += 1;
+  }
+  return { enrichedCount, failedCount, fragments };
+}
+
+// src/session/snapshotSession.ts
+function isVslDiff(result) {
+  return "changes" in result;
+}
+function flattenObjects(objects, map) {
+  for (const object of objects) {
+    map.set(object.id, object);
+    flattenObjects(object.ch ?? [], map);
+  }
+}
+function storeTree(store, objects) {
+  for (const object of objects) {
+    store.set(object.id, object);
+    storeTree(store, object.ch ?? []);
+  }
+}
+var VslSnapshotSession = class {
+  store;
+  lastUrl = null;
+  lastViewport = null;
+  lastDocument = null;
+  version = 0;
+  constructor(store = createCacheStore()) {
+    this.store = store;
+  }
+  /**
+   * Строит VSL из DOM поддерева root (extractDomTree → segmentTree →
+   * buildVslDocument) и возвращает полный документ либо дифф (см. шапку).
+   */
+  snapshot(root, input) {
+    const elements = segmentTree(extractDomTree(root));
+    return this.commit(elements, this.buildOptions(root, input), input);
+  }
+  /**
+   * Vision-вариант конвейера (T1.5.5): segmentTree → enrichWithVision (Level 5
+   * fallback — аннотация t + vf/vf_meta на элементах ДО сборки) → buildVslDocument
+   * → cache/diff — та же логика состояния, что snapshot(). Синхронный snapshot()
+   * сохранён (существующие контракты/тесты не ломаются); данные фрагментов
+   * (base64) возвращаются ОТДЕЛЬНО — в документе только метаданные (DEC-015).
+   */
+  async snapshotWithVision(root, input, vision) {
+    const elements = segmentTree(extractDomTree(root));
+    const visionResult = await enrichWithVision(elements, vision);
+    const snapshot = this.commit(elements, this.buildOptions(root, input), input);
+    return { snapshot, fragments: visionResult.fragments };
+  }
+  /** BuildOptions из input + портативный title (логика бывшего snapshot()). */
+  buildOptions(root, input) {
+    const options = {
+      viewport: { width: input.viewport.width, height: input.viewport.height },
+      url: input.url
+    };
+    options.title = input.title ?? root.ownerDocument.title;
+    if (input.timestamp !== void 0) options.timestamp = input.timestamp;
+    if (input.background !== void 0) options.background = input.background;
+    return options;
+  }
+  /** Сборка документа + кэш/дифф (логика бывшего snapshot(), см. шапку модуля). */
+  commit(elements, options, input) {
+    const nextDocument = buildVslDocument(elements, options);
+    const firstCall = this.lastDocument === null;
+    const urlChanged = !firstCall && input.url !== this.lastUrl;
+    if (firstCall || urlChanged) {
+      this.store.clear();
+      storeTree(this.store, nextDocument.objects);
+      this.version = 1;
+      this.lastUrl = input.url;
+      this.lastViewport = { ...input.viewport };
+      this.lastDocument = nextDocument;
+      return nextDocument;
+    }
+    const viewportChanged = this.lastViewport === null || input.viewport.width !== this.lastViewport.width || input.viewport.height !== this.lastViewport.height;
+    if (viewportChanged) this.store.invalidateCoordinates();
+    const diffOptions = {
+      diffVersion: this.version + 1,
+      baseVersion: this.version
+    };
+    if (input.timestamp !== void 0) diffOptions.timestamp = input.timestamp;
+    const diff = diffVslDocuments(this.lastDocument, nextDocument, diffOptions);
+    const fresh = /* @__PURE__ */ new Map();
+    flattenObjects(nextDocument.objects, fresh);
+    for (const removed of diff.changes.removed) this.store.invalidate(removed.id);
+    for (const modified of diff.changes.modified) {
+      const object = fresh.get(modified.id);
+      if (object !== void 0) this.store.set(object.id, object);
+    }
+    for (const added of diff.changes.added) storeTree(this.store, [added]);
+    this.version = diff.diff_version;
+    this.lastUrl = input.url;
+    this.lastViewport = { ...input.viewport };
+    this.lastDocument = nextDocument;
+    return diff;
+  }
+};
+
+// src/llm/types.ts
+var LlmError = class extends Error {
+  /** HTTP-статус, если ошибка пришла от API (для классификации retry). */
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "LlmError";
+    this.status = status;
+  }
+};
+var LlmValidationError = class extends LlmError {
+  constructor(message) {
+    super(message);
+    this.name = "LlmValidationError";
+  }
+};
+
+// src/llm/actions.ts
+var VALID_ACTIONS = [
+  // §7.1 Базовые
+  "click",
+  "type",
+  "clear",
+  "scroll",
+  "hover",
+  "focus",
+  "blur",
+  "select",
+  "check",
+  "uncheck",
+  // §7.2 Расширенные
+  "drag",
+  "drop",
+  "submit",
+  "reset",
+  "open",
+  "close",
+  "expand",
+  "collapse",
+  "wait",
+  // §7.3 Навигационные
+  "navigate",
+  "go_back",
+  "go_forward",
+  "refresh",
+  // §7.4 Загрузка файлов
+  "download"
+];
+var TARGET_ACTIONS = /* @__PURE__ */ new Set([
+  "click",
+  "type",
+  "clear",
+  "hover",
+  "focus",
+  "blur",
+  "select",
+  "check",
+  "uncheck",
+  "drag",
+  "drop",
+  "submit",
+  "reset",
+  "open",
+  "close",
+  "expand",
+  "collapse",
+  "download"
+]);
+var collectFromObjects = (objects, ids) => {
+  for (const object of objects) {
+    ids.add(object.id);
+    collectFromObjects(object.ch ?? [], ids);
+  }
+};
+function collectIds(vslJson) {
+  const ids = /* @__PURE__ */ new Set();
+  if (isVslDiff(vslJson)) {
+    collectFromObjects(vslJson.changes.added, ids);
+    for (const modified of vslJson.changes.modified) ids.add(modified.id);
+    for (const ref of vslJson.changes.unchanged_refs) ids.add(ref);
+  } else {
+    collectFromObjects(vslJson.objects, ids);
+  }
+  return ids;
+}
+function validateAction(raw, validIds) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new LlmValidationError("Model response: action must be a JSON object");
+  }
+  const record = raw;
+  const action = record.action;
+  if (typeof action !== "string" || !VALID_ACTIONS.includes(action)) {
+    const shown = typeof action === "string" ? action : JSON.stringify(action) ?? "undefined";
+    throw new LlmValidationError(`Unknown action: ${shown}`);
+  }
+  const result = { action };
+  if (TARGET_ACTIONS.has(action)) {
+    const targetId = record.target_id;
+    if (typeof targetId !== "string") {
+      throw new LlmValidationError(`Action "${action}" requires a string target_id`);
+    }
+    if (!validIds.has(targetId)) {
+      throw new LlmValidationError(`target_id "${targetId}" not found in VSL JSON`);
+    }
+    result.target_id = targetId;
+  }
+  const value = record.value;
+  if (typeof value === "string" || value === null) result.value = value;
+  const reasoning = record.reasoning;
+  if (typeof reasoning === "string") result.reasoning = reasoning;
+  return result;
+}
+
+// src/llm/prompt.ts
+var FEW_SHOT_EXAMPLES = [
+  {
+    title: "Example 1 \u2014 click a button (full document)",
+    vsl: '{"vsl_version":"1.0.0","objects":[{"id":"header_0","t":"header","ch":[{"id":"link_0_0","t":"link","txt":"\u0412\u043E\u0439\u0442\u0438","act":["click"]},{"id":"link_0_1","t":"link","txt":"\u0420\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u044F","act":["click"]}]}]}',
+    goal: "\u0412\u043E\u0439\u0442\u0438 \u0432 \u0430\u043A\u043A\u0430\u0443\u043D\u0442",
+    action: '{"action":"click","target_id":"link_0_0","value":null,"reasoning":"\u0421\u0441\u044B\u043B\u043A\u0430 \xAB\u0412\u043E\u0439\u0442\u0438\xBB \u043E\u0442\u043A\u0440\u044B\u0432\u0430\u0435\u0442 \u0444\u043E\u0440\u043C\u0443 \u0432\u0445\u043E\u0434\u0430"}'
+  },
+  {
+    title: "Example 2 \u2014 fill a form (diff input)",
+    vsl: '{"diff_version":2,"base_version":1,"changes":{"added":[{"id":"form_1_0","t":"input","txt":"\u041F\u043E\u0438\u0441\u043A","act":["click","type"]}],"modified":[],"removed":[],"unchanged_refs":["button_1_1"]}}',
+    goal: "\u041D\u0430\u0439\u0442\u0438 \xABvsl json\xBB",
+    action: '{"action":"type","target_id":"form_1_0","value":"vsl json","reasoning":"\u0412\u0432\u043E\u0436\u0443 \u0437\u0430\u043F\u0440\u043E\u0441 \u0432 \u043D\u043E\u0432\u043E\u0435 \u043F\u043E\u043B\u0435 \u043F\u043E\u0438\u0441\u043A\u0430 \u0438\u0437 \u0434\u0438\u0444\u0444\u0430; \u0437\u0430\u0442\u0435\u043C \u043D\u0430\u0436\u043C\u0443 button_1_1 \u0438\u0437 unchanged_refs"}'
+  },
+  {
+    title: "Example 3 \u2014 navigation",
+    vsl: '{"vsl_version":"1.0.0","objects":[{"id":"main_0","t":"main","ch":[{"id":"header_0_0","t":"header","txt":"\u041D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438"}]}]}',
+    goal: "\u041E\u0442\u043A\u0440\u044B\u0442\u044C \u0441\u0442\u0440\u0430\u043D\u0438\u0446\u0443 \u043D\u0430\u0441\u0442\u0440\u043E\u0435\u043A \u043F\u043E \u043F\u0440\u044F\u043C\u043E\u0439 \u0441\u0441\u044B\u043B\u043A\u0435",
+    action: '{"action":"navigate","value":"https://example.com/settings","reasoning":"\u0426\u0435\u043B\u0435\u0432\u043E\u0439 URL \u0438\u0437\u0432\u0435\u0441\u0442\u0435\u043D \u2014 \u043F\u0440\u044F\u043C\u0430\u044F \u043D\u0430\u0432\u0438\u0433\u0430\u0446\u0438\u044F \u0431\u044B\u0441\u0442\u0440\u0435\u0435"}'
+  }
+];
+var PARAMETER_CONVENTIONS = [
+  "- click, hover, focus, blur, clear, check, uncheck, open, close, expand, collapse \u2014 target_id;",
+  "- type \u2014 target_id + value (text to type);",
+  "- select \u2014 target_id + value (option);",
+  '- scroll \u2014 value: "up" | "down" (optional amount: "down:300");',
+  "- drag \u2014 target_id: source element, value: destination element id;",
+  "- submit, reset \u2014 target_id: form id;",
+  '- wait \u2014 value: condition (e.g. a selector or "idle");',
+  "- navigate \u2014 value: URL;",
+  "- download \u2014 target_id (element to click) OR value (URL to download directly);",
+  "- go_back, go_forward, refresh \u2014 no parameters."
+].join("\n");
+function buildSystemPrompt() {
+  const actions = VALID_ACTIONS.join(" | ");
+  const examples = FEW_SHOT_EXAMPLES.map(
+    (example) => `${example.title}
+VSL JSON: ${example.vsl}
+User goal: ${example.goal}
+Action: ${example.action}`
+  ).join("\n\n");
+  return [
+    "You are a screen understanding agent. You receive a VSL JSON representation of the current screen. Analyze the structure and decide what action to take to accomplish the user's goal.",
+    "",
+    "## VSL JSON format",
+    "",
+    'Elements form a tree via "ch" (children). Element keys:',
+    '- "id" \u2014 deterministic unique element id; the ONLY valid value for target_id;',
+    '- "t" \u2014 semantic type: button | input | link | nav | header | main | container | image | select | textarea | modal | tab;',
+    '- "r" \u2014 ARIA role (clarifies semantics);',
+    '- "p" \u2014 position [x, y], relative 0.0\u20131.0 of the viewport;',
+    '- "s" \u2014 size [width, height] in pixels;',
+    '- "st" \u2014 state: checked | expanded | disabled;',
+    '- "txt" \u2014 visible text or accessible label;',
+    '- "act" \u2014 actions the element supports (e.g. ["click"]);',
+    '- "vf" / "vf_meta" \u2014 optional visual fragment reference; matching image content, if provided, is attached as separate image blocks.',
+    "",
+    "The input is either a full document:",
+    '{"vsl_version": "...", "canvas": {...}, "objects": [...]}',
+    "or a diff (diff-first mode):",
+    '{"diff_version": N, "base_version": M, "changes": {"added": [...], "modified": [...], "removed": [...], "unchanged_refs": [...]}}',
+    "",
+    "Diff semantics:",
+    '- "added" \u2014 new subtrees, fully described;',
+    '- "modified" \u2014 objects carrying ONLY the changed fields;',
+    '- "removed" \u2014 ids that no longer exist: NEVER target them;',
+    '- "unchanged_refs" \u2014 known unchanged elements: valid targets.',
+    "",
+    "## Lazy text loading (M1.7)",
+    "",
+    "When an element text exceeds 200 characters, the VSL JSON contains only:",
+    '- "txt_preview" \u2014 first ~50 characters of the text (with ellipsis);',
+    '- "txt_ref" \u2014 reference to the full text block (format: tb_xxx, e.g. tb_001).',
+    "",
+    'The full text is stored in "text_blocks" at the document root. To retrieve it, call the MCP tool vsl_get_text_block with {block_id: "<txt_ref value>"}.',
+    "",
+    'When to fetch full text: only when the user goal REQUIRES reading the content of a long text (e.g. "find the paragraph about X", "click the link in the article about Y"). For navigation by headings/titles \u2014 txt_preview is sufficient.',
+    "",
+    "## Actions",
+    "",
+    "Respond with exactly ONE next action. Allowed actions:",
+    actions + ".",
+    "",
+    "Unified parameter format {action, target_id, value, reasoning}:",
+    PARAMETER_CONVENTIONS,
+    "",
+    "## Response rules",
+    "",
+    "1. Respond ONLY by calling the execute_action tool with one object:",
+    '   {"action": "...", "target_id": "...", "value": null, "reasoning": "..."}',
+    "2. When required, target_id MUST be an id present in the provided VSL JSON (document or diff, including unchanged_refs).",
+    "3. Never target removed ids; never invent ids or actions outside the allowed list.",
+    '4. Prefer the smallest action that moves toward the goal; explain briefly in "reasoning".',
+    "",
+    "## Examples",
+    "",
+    examples
+  ].join("\n");
+}
+function buildUserPrompt(vslJson, goal) {
+  return `Current screen (VSL JSON):
+${JSON.stringify(vslJson)}
+
+User goal: ${goal}`;
+}
+function collectFragmentData(vslJson, store) {
+  if (store === void 0 || store.size === 0) return [];
+  const refs = /* @__PURE__ */ new Set();
+  const visit = (objects) => {
+    for (const object of objects) {
+      const vf = object.vf;
+      if (typeof vf === "string") refs.add(vf);
+      visit(object.ch ?? []);
+    }
+  };
+  if (isVslDiff(vslJson)) {
+    visit(vslJson.changes.added);
+    for (const modified of vslJson.changes.modified) {
+      const vf = modified.vf;
+      if (typeof vf === "string") refs.add(vf);
+    }
+  } else {
+    visit(vslJson.objects);
+  }
+  const fragments = [];
+  for (const ref of refs) {
+    const data = store.get(ref);
+    if (data !== void 0) fragments.push(data);
+  }
+  return fragments;
+}
+
+// src/llm/schema.ts
+var ACTION_TOOL_NAME = "execute_action";
+var ACTION_TOOL_DESCRIPTION = "Execute exactly one next browser action toward the user goal.";
+var ACTION_TOOL_SCHEMA = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      description: "Action name from the Action Model (ARCHITECTURE.md \xA77.1\u20137.3).",
+      enum: [...VALID_ACTIONS]
+    },
+    target_id: {
+      type: "string",
+      description: "Element id from the provided VSL JSON (required for target actions)."
+    },
+    value: {
+      type: ["string", "null"],
+      description: "Value for parameterized actions: type/select/scroll/navigate/wait/drag."
+    },
+    reasoning: {
+      type: "string",
+      description: "Brief explanation of the chosen action."
+    }
+  },
+  required: ["action"],
+  additionalProperties: false
+};
+
+// src/llm/transport.ts
+var defaultTransport = (url, init) => fetch(url, init);
+var defaultSleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+var backoffDelayMs = (attempt) => 2 ** attempt * 1e3;
+var isRetryable = (error) => {
+  if (error instanceof LlmError) {
+    return error.status === void 0 || error.status === 429 || error.status >= 500;
+  }
+  return true;
+};
+async function retryWithBackoff(operation, options = {}) {
+  const maxRetries = Math.max(1, options.maxRetries ?? 3);
+  const sleep2 = options.sleep ?? defaultSleep;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isRetryable(error) || attempt >= maxRetries - 1) throw error;
+      await sleep2(backoffDelayMs(attempt));
+    }
+  }
+}
+async function executeJsonWithRetry(transport, url, init, providerLabel, options = {}) {
+  const response = await retryWithBackoff(async () => {
+    let res;
+    try {
+      res = await transport(url, init);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new LlmError(`${providerLabel}: network error \u2014 ${message}`);
+    }
+    if (!res.ok) {
+      throw new LlmError(`${providerLabel}: HTTP ${res.status} ${res.statusText}`, res.status);
+    }
+    return res;
+  }, options);
+  try {
+    return await response.json();
+  } catch {
+    throw new LlmError(`${providerLabel}: response is not valid JSON`);
+  }
+}
+
+// src/llm/openai.ts
+var DEFAULT_MODEL = "gpt-4o";
+var DEFAULT_BASE_URL = "https://api.openai.com/v1";
+var OpenAIAdapter = class {
+  apiKey;
+  model;
+  baseUrl;
+  maxRetries;
+  transport;
+  sleep;
+  constructor(config) {
+    if (config.apiKey.length === 0) {
+      throw new LlmError("OpenAIAdapter: apiKey is required");
+    }
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? DEFAULT_MODEL;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.maxRetries = config.maxRetries ?? 3;
+    this.transport = config.transport ?? defaultTransport;
+    this.sleep = config.sleep;
+  }
+  async sendPrompt(vslJson, task, options) {
+    const userContent = [
+      { type: "text", text: buildUserPrompt(vslJson, task) },
+      ...collectFragmentData(vslJson, options?.visualFragments).map((fragment) => ({
+        type: "image",
+        mediaType: fragment.mediaType,
+        data: fragment.data
+      }))
+    ];
+    return this.sendRaw(buildSystemPrompt(), userContent, {
+      name: ACTION_TOOL_NAME,
+      description: ACTION_TOOL_DESCRIPTION,
+      schema: ACTION_TOOL_SCHEMA
+    });
+  }
+  /**
+   * Низкоуровневый вызов (T1.5.4, вариант C): провайдер-независимые аргументы
+   * → Chat Completions → LlmResponse. Потребители: sendPrompt (tool
+   * «execute_action») и LlmVisionClassifier (tool «classify_fragment»).
+   * Retry (§10.3) и парсинг tool_calls живут здесь в одном месте.
+   */
+  async sendRaw(system, userContent, tool) {
+    const content = userContent.map(
+      (part) => part.type === "text" ? { type: "text", text: part.text } : {
+        type: "image_url",
+        image_url: { url: `data:${part.mediaType};base64,${part.data}` }
+      }
+    );
+    const body = {
+      model: this.model,
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content }
+      ],
+      tools: [
+        {
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.schema
+          }
+        }
+      ],
+      tool_choice: { type: "function", function: { name: tool.name } }
+    };
+    const data = await executeJsonWithRetry(
+      this.transport,
+      `${this.baseUrl}/chat/completions`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body)
+      },
+      "OpenAI",
+      { maxRetries: this.maxRetries, sleep: this.sleep }
+    );
+    const message = data.choices?.[0]?.message;
+    const toolCall = message?.tool_calls?.[0];
+    let rawAction;
+    const args = toolCall?.function?.arguments;
+    if (args !== void 0) {
+      try {
+        rawAction = JSON.parse(args);
+      } catch {
+        throw new LlmError("OpenAI: tool_call.arguments is not valid JSON");
+      }
+    }
+    return {
+      text: message?.content ?? null,
+      action: rawAction,
+      model: data.model ?? this.model,
+      usage: {
+        inputTokens: data.usage?.prompt_tokens,
+        outputTokens: data.usage?.completion_tokens
+      }
+    };
+  }
+  /** Convenience §9.4: решение для цели + валидация (whitelist + target_id). */
+  async decide(input) {
+    const response = await this.sendPrompt(input.vslJson, input.goal, {
+      visualFragments: input.visualFragments
+    });
+    return validateAction(response.action, collectIds(input.vslJson));
+  }
+};
+
+// src/llm/anthropic.ts
+var DEFAULT_MODEL2 = "claude-sonnet-4-20250514";
+var DEFAULT_BASE_URL2 = "https://api.anthropic.com";
+var ANTHROPIC_VERSION = "2023-06-01";
+var DEFAULT_MAX_TOKENS = 1024;
+var AnthropicAdapter = class {
+  apiKey;
+  model;
+  baseUrl;
+  maxTokens;
+  maxRetries;
+  transport;
+  sleep;
+  constructor(config) {
+    if (config.apiKey.length === 0) {
+      throw new LlmError("AnthropicAdapter: apiKey is required");
+    }
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? DEFAULT_MODEL2;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/, "");
+    this.maxTokens = DEFAULT_MAX_TOKENS;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.transport = config.transport ?? defaultTransport;
+    this.sleep = config.sleep;
+  }
+  async sendPrompt(vslJson, task, options) {
+    const userContent = [
+      { type: "text", text: buildUserPrompt(vslJson, task) },
+      ...collectFragmentData(vslJson, options?.visualFragments).map((fragment) => ({
+        type: "image",
+        mediaType: fragment.mediaType,
+        data: fragment.data
+      }))
+    ];
+    return this.sendRaw(buildSystemPrompt(), userContent, {
+      name: ACTION_TOOL_NAME,
+      description: ACTION_TOOL_DESCRIPTION,
+      schema: ACTION_TOOL_SCHEMA
+    });
+  }
+  /**
+   * Низкоуровневый вызов (T1.5.4, вариант C): провайдер-независимые аргументы
+   * → Messages API → LlmResponse. Потребители: sendPrompt (tool
+   * «execute_action») и LlmVisionClassifier (tool «classify_fragment»).
+   * tool_use-блоки фильтруются по tool.name (ранее — константа ACTION_TOOL_NAME):
+   * параметризация безопасна, sendPrompt передаёт ACTION_TOOL_NAME.
+   */
+  async sendRaw(system, userContent, tool) {
+    const content = userContent.map(
+      (part) => part.type === "text" ? { type: "text", text: part.text } : {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: part.mediaType,
+          data: part.data
+        }
+      }
+    );
+    const body = {
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system,
+      messages: [{ role: "user", content }],
+      tools: [
+        {
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.schema
+        }
+      ],
+      tool_choice: { type: "tool", name: tool.name }
+    };
+    const data = await executeJsonWithRetry(
+      this.transport,
+      `${this.baseUrl}/v1/messages`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": ANTHROPIC_VERSION
+        },
+        body: JSON.stringify(body)
+      },
+      "Anthropic",
+      { maxRetries: this.maxRetries, sleep: this.sleep }
+    );
+    let text = null;
+    let rawAction;
+    for (const block of data.content ?? []) {
+      if (block.type === "text" && typeof block.text === "string") {
+        text = text === null ? block.text : `${text}
+${block.text}`;
+      } else if (block.type === "tool_use" && block.name === tool.name) {
+        rawAction = block.input;
+      }
+    }
+    return {
+      text,
+      action: rawAction,
+      model: data.model ?? this.model,
+      usage: {
+        inputTokens: data.usage?.input_tokens,
+        outputTokens: data.usage?.output_tokens
+      }
+    };
+  }
+  /** Convenience §9.4: решение для цели + валидация (whitelist + target_id). */
+  async decide(input) {
+    const response = await this.sendPrompt(input.vslJson, input.goal, {
+      visualFragments: input.visualFragments
+    });
+    return validateAction(response.action, collectIds(input.vslJson));
+  }
+};
+
+// src/llm/alibaba.ts
+var DEFAULT_MODEL3 = "qwen3.8-flash";
+var DEFAULT_BASE_URL3 = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+var AlibabaAdapter = class {
+  apiKey;
+  model;
+  baseUrl;
+  maxRetries;
+  transport;
+  sleep;
+  constructor(config) {
+    if (config.apiKey.length === 0) {
+      throw new LlmError("AlibabaAdapter: apiKey is required");
+    }
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? DEFAULT_MODEL3;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL3).replace(/\/+$/, "");
+    this.maxRetries = config.maxRetries ?? 3;
+    this.transport = config.transport ?? defaultTransport;
+    this.sleep = config.sleep;
+  }
+  async sendPrompt(vslJson, task, options) {
+    const userContent = [
+      { type: "text", text: buildUserPrompt(vslJson, task) },
+      ...collectFragmentData(vslJson, options?.visualFragments).map((fragment) => ({
+        type: "image",
+        mediaType: fragment.mediaType,
+        data: fragment.data
+      }))
+    ];
+    return this.sendRaw(buildSystemPrompt(), userContent, {
+      name: ACTION_TOOL_NAME,
+      description: ACTION_TOOL_DESCRIPTION,
+      schema: ACTION_TOOL_SCHEMA
+    });
+  }
+  /**
+   * Низкоуровневый вызов (T1.5.4, вариант C): провайдер-независимые аргументы
+   * → DashScope Chat Completions → LlmResponse. Потребители: sendPrompt (tool
+   * «execute_action») и LlmVisionClassifier (tool «classify_fragment»).
+   * Retry (§10.3) и парсинг tool_calls живут здесь в одном месте.
+   */
+  async sendRaw(system, userContent, tool) {
+    const content = userContent.map(
+      (part) => part.type === "text" ? { type: "text", text: part.text } : {
+        type: "image_url",
+        image_url: { url: `data:${part.mediaType};base64,${part.data}` }
+      }
+    );
+    const body = {
+      model: this.model,
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content }
+      ],
+      tools: [
+        {
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.schema
+          }
+        }
+      ],
+      tool_choice: { type: "function", function: { name: tool.name } }
+    };
+    const data = await executeJsonWithRetry(
+      this.transport,
+      `${this.baseUrl}/chat/completions`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body)
+      },
+      "Alibaba/Qwen",
+      { maxRetries: this.maxRetries, sleep: this.sleep }
+    );
+    const message = data.choices?.[0]?.message;
+    const toolCall = message?.tool_calls?.[0];
+    let rawAction;
+    const args = toolCall?.function?.arguments;
+    if (args !== void 0) {
+      try {
+        rawAction = JSON.parse(args);
+      } catch {
+        throw new LlmError("Alibaba/Qwen: tool_call.arguments is not valid JSON");
+      }
+    }
+    return {
+      text: message?.content ?? null,
+      action: rawAction,
+      model: data.model ?? this.model,
+      usage: {
+        inputTokens: data.usage?.prompt_tokens,
+        outputTokens: data.usage?.completion_tokens
+      }
+    };
+  }
+  /** Convenience §9.4: решение для цели + валидация (whitelist + target_id). */
+  async decide(input) {
+    const response = await this.sendPrompt(input.vslJson, input.goal, {
+      visualFragments: input.visualFragments
+    });
+    return validateAction(response.action, collectIds(input.vslJson));
+  }
+};
+
+// src/executor/types.ts
+var ActionExecutionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ActionExecutionError";
+  }
+};
+
+// src/executor/resolveTarget.ts
+var ID_SEPARATOR = "_";
+var INDEX_SEGMENT_RE = /^\d+$/;
+function defaultRoot2() {
+  const body = document.body;
+  if (body === null) {
+    throw new ActionExecutionError(
+      "resolveTarget: document.body is not available \u2014 pass the snapshot root via ExecutorOptions.root"
+    );
+  }
+  return body;
+}
+function parseTargetId(targetId) {
+  const segments = targetId.split(ID_SEPARATOR);
+  const tag = segments[0];
+  if (tag === void 0 || tag.length === 0) {
+    throw new ActionExecutionError(
+      `Invalid target_id "${targetId}": missing tag \u2014 expected format "tag_index1_index2_..."`
+    );
+  }
+  const indexSegments = segments.slice(1);
+  if (indexSegments.length === 0) {
+    throw new ActionExecutionError(
+      `Invalid target_id "${targetId}": missing index path \u2014 expected format "tag_index1_index2_..."`
+    );
+  }
+  const indexPath = [];
+  for (const segment of indexSegments) {
+    if (!INDEX_SEGMENT_RE.test(segment)) {
+      throw new ActionExecutionError(
+        `Invalid target_id "${targetId}": index segment "${segment}" is not a non-negative integer`
+      );
+    }
+    indexPath.push(Number(segment));
+  }
+  return { tag, indexPath };
+}
+function resolveTarget(targetId, options = {}) {
+  const root = options.root ?? defaultRoot2();
+  const { tag, indexPath } = parseTargetId(targetId);
+  let current = root;
+  let depth = 0;
+  for (const index of indexPath) {
+    depth += 1;
+    const next = current.children[index];
+    if (next === void 0) {
+      throw new ActionExecutionError(
+        `Failed to resolve target_id "${targetId}": no element child at index ${index} on depth ${depth} \u2014 DOM may have changed since the snapshot`
+      );
+    }
+    current = next;
+  }
+  const actualTag = current.tagName.toLowerCase();
+  if (actualTag !== tag) {
+    throw new ActionExecutionError(
+      `Failed to resolve target_id "${targetId}": found <${actualTag}>, expected tag "${tag}" \u2014 DOM may have changed since the snapshot`
+    );
+  }
+  return current;
+}
+
+// src/executor/actionExecutor.ts
+var DEFAULT_SCROLL_AMOUNT = 300;
+var SCROLL_DIRECTIONS = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
+var WAIT_DEFAULT_TIMEOUT_MS = 5e3;
+var WAIT_POLL_INTERVAL_MS = 50;
+function resolveTargetOf(action, options) {
+  const targetId = action.target_id;
+  if (typeof targetId !== "string") {
+    throw new ActionExecutionError(`Action "${action.action}" requires a string target_id`);
+  }
+  return resolveTarget(targetId, options);
+}
+function requireValue(action) {
+  const value = action.value;
+  if (typeof value !== "string") {
+    throw new ActionExecutionError(`Action "${action.action}" requires a string value`);
+  }
+  return value;
+}
+function dispatchValueEvents(el) {
+  el.dispatchEvent(new Event("input", { bubbles: true }));
+  el.dispatchEvent(new Event("change", { bubbles: true }));
+}
+function requireTextTarget(action, el) {
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+    return el;
+  }
+  throw new ActionExecutionError(
+    `Action "${action.action}" requires an <input> or <textarea> target, got <${el.tagName.toLowerCase()}>`
+  );
+}
+function typeInto(el, text) {
+  el.value = text;
+  dispatchValueEvents(el);
+}
+function clickElement(el) {
+  if (typeof el.click === "function") {
+    el.click();
+    return;
+  }
+  el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+}
+function hoverElement(el) {
+  el.dispatchEvent(new MouseEvent("mouseover", { bubbles: true, cancelable: true }));
+  el.dispatchEvent(new MouseEvent("mouseenter", { bubbles: false }));
+}
+function focusableOrThrow(action, el) {
+  const htmlEl = el;
+  if (typeof htmlEl.focus !== "function" || typeof htmlEl.blur !== "function") {
+    throw new ActionExecutionError(
+      `Action "${action.action}" requires a focusable element, got <${el.tagName.toLowerCase()}>`
+    );
+  }
+  return htmlEl;
+}
+function selectOption(el, raw) {
+  if (!(el instanceof HTMLSelectElement)) {
+    throw new ActionExecutionError(
+      `Action "select" requires a <select> target, got <${el.tagName.toLowerCase()}>`
+    );
+  }
+  const wanted = raw.trim();
+  for (const option of Array.from(el.options)) {
+    if (option.value === raw) {
+      el.value = option.value;
+      dispatchValueEvents(el);
+      return;
+    }
+  }
+  for (const option of Array.from(el.options)) {
+    if (option.text.trim() === wanted) {
+      el.value = option.value;
+      dispatchValueEvents(el);
+      return;
+    }
+  }
+  throw new ActionExecutionError(
+    `Action "select": option "${raw}" not found in <select> (neither by value nor by visible text)`
+  );
+}
+function setChecked(el, action, checked) {
+  if (!(el instanceof HTMLInputElement) || el.type !== "checkbox" && el.type !== "radio") {
+    throw new ActionExecutionError(
+      `Action "${action.action}" requires an <input type="checkbox"> or <input type="radio"> target, got <${el.tagName.toLowerCase()}>`
+    );
+  }
+  el.checked = checked;
+  dispatchValueEvents(el);
+}
+function parseScrollValue(value, defaultAmount) {
+  const parts = value.trim().split(":");
+  const dir = parts[0] ?? "";
+  const amountPart = parts[1];
+  if (parts.length > 2 || !SCROLL_DIRECTIONS.has(dir)) {
+    throw new ActionExecutionError(
+      `Invalid scroll value "${value}" \u2014 expected "up", "down", "left", "right" or "dir:amount" (e.g. "down:300")`
+    );
+  }
+  let amount = defaultAmount;
+  if (amountPart !== void 0) {
+    if (!/^\d+(?:\.\d+)?$/.test(amountPart)) {
+      throw new ActionExecutionError(
+        `Invalid scroll amount in "${value}" \u2014 expected a positive number, e.g. "down:300"`
+      );
+    }
+    amount = Number(amountPart);
+  }
+  const dx = dir === "left" ? -amount : dir === "right" ? amount : 0;
+  const dy = dir === "up" ? -amount : dir === "down" ? amount : 0;
+  return { dx, dy };
+}
+function dispatchDragEvent(target, type) {
+  if (typeof DragEvent === "function") {
+    target.dispatchEvent(new DragEvent(type, { bubbles: true, cancelable: true }));
+  } else {
+    target.dispatchEvent(new Event(type, { bubbles: true, cancelable: true }));
+  }
+}
+function requireForm(action, el) {
+  if (el instanceof HTMLFormElement) {
+    return el;
+  }
+  throw new ActionExecutionError(
+    `Action "${action.action}" requires a <form> target, got <${el.tagName.toLowerCase()}>`
+  );
+}
+function setOpenState(action, el, open) {
+  if (typeof HTMLDialogElement !== "undefined" && el instanceof HTMLDialogElement) {
+    if (open) {
+      el.showModal();
+    } else {
+      el.close();
+    }
+    return;
+  }
+  if (el instanceof HTMLDetailsElement) {
+    el.open = open;
+    return;
+  }
+  throw new ActionExecutionError(
+    `Action "${action.action}" requires a <dialog> or <details> target, got <${el.tagName.toLowerCase()}>`
+  );
+}
+function setExpanded(action, el, expanded) {
+  if (el instanceof HTMLDetailsElement) {
+    el.open = expanded;
+    return;
+  }
+  if (el.hasAttribute("aria-expanded")) {
+    el.setAttribute("aria-expanded", expanded ? "true" : "false");
+    return;
+  }
+  throw new ActionExecutionError(
+    `Action "${action.action}" requires a <details> or an element with aria-expanded, got <${el.tagName.toLowerCase()}>`
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function isWaitSatisfied(value) {
+  if (value.trim() === "idle") {
+    return document.readyState === "complete";
+  }
+  try {
+    return document.querySelector(value) !== null;
+  } catch {
+    throw new ActionExecutionError(`wait: invalid selector "${value}"`);
+  }
+}
+async function waitForValue(value, options) {
+  const timeoutMs = options.waitTimeout ?? WAIT_DEFAULT_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    if (isWaitSatisfied(value)) {
+      return;
+    }
+    if (Date.now() >= deadline) {
+      throw new ActionExecutionError(
+        `wait: condition "${value}" is not met within ${timeoutMs}ms`
+      );
+    }
+    await sleep(WAIT_POLL_INTERVAL_MS);
+  }
+}
+async function executeAction(action, options = {}) {
+  const targetId = action.target_id;
+  const echo = {
+    success: false,
+    action: action.action,
+    ...typeof targetId === "string" ? { targetId } : {}
+  };
+  try {
+    switch (action.action) {
+      // ——— §7.1 Базовые (T1.4.1) ———
+      case "click":
+        clickElement(resolveTargetOf(action, options));
+        break;
+      case "type":
+        typeInto(
+          requireTextTarget(action, resolveTargetOf(action, options)),
+          requireValue(action)
+        );
+        break;
+      case "clear": {
+        const field = requireTextTarget(action, resolveTargetOf(action, options));
+        typeInto(field, "");
+        break;
+      }
+      case "scroll": {
+        const amount = options.defaultScrollAmount ?? DEFAULT_SCROLL_AMOUNT;
+        const { dx, dy } = parseScrollValue(requireValue(action), amount);
+        window.scrollBy(dx, dy);
+        break;
+      }
+      case "hover":
+        hoverElement(resolveTargetOf(action, options));
+        break;
+      case "focus":
+        focusableOrThrow(action, resolveTargetOf(action, options)).focus();
+        break;
+      case "blur":
+        focusableOrThrow(action, resolveTargetOf(action, options)).blur();
+        break;
+      case "select":
+        selectOption(resolveTargetOf(action, options), requireValue(action));
+        break;
+      case "check":
+        setChecked(resolveTargetOf(action, options), action, true);
+        break;
+      case "uncheck":
+        setChecked(resolveTargetOf(action, options), action, false);
+        break;
+      // ——— §7.2 Расширенные (T1.4.2) ———
+      case "drag": {
+        const destinationId = requireValue(action);
+        const source = resolveTargetOf(action, options);
+        const destination = resolveTarget(destinationId, options);
+        dispatchDragEvent(source, "dragstart");
+        dispatchDragEvent(destination, "dragenter");
+        dispatchDragEvent(destination, "dragover");
+        dispatchDragEvent(destination, "drop");
+        dispatchDragEvent(source, "dragend");
+        break;
+      }
+      case "drop": {
+        const dropTarget = resolveTargetOf(action, options);
+        dispatchDragEvent(dropTarget, "dragover");
+        dispatchDragEvent(dropTarget, "drop");
+        break;
+      }
+      case "submit": {
+        const form = requireForm(action, resolveTargetOf(action, options));
+        form.dispatchEvent(new Event("submit", { bubbles: true, cancelable: true }));
+        break;
+      }
+      case "reset":
+        requireForm(action, resolveTargetOf(action, options)).reset();
+        break;
+      case "open":
+        setOpenState(action, resolveTargetOf(action, options), true);
+        break;
+      case "close":
+        setOpenState(action, resolveTargetOf(action, options), false);
+        break;
+      case "expand":
+        setExpanded(action, resolveTargetOf(action, options), true);
+        break;
+      case "collapse":
+        setExpanded(action, resolveTargetOf(action, options), false);
+        break;
+      case "wait":
+        await waitForValue(requireValue(action), options);
+        break;
+      // ——— §7.3 Навигационные (T1.4.3) ———
+      case "navigate":
+        window.location.assign(requireValue(action));
+        break;
+      case "go_back":
+        window.history.back();
+        break;
+      case "go_forward":
+        window.history.forward();
+        break;
+      case "refresh":
+        window.location.reload();
+        break;
+      case "download": {
+        const downloadTargetId = action.target_id;
+        const downloadValue = action.value;
+        if (typeof downloadTargetId === "string") {
+          const el = resolveTarget(downloadTargetId, options);
+          clickElement(el);
+          break;
+        }
+        if (typeof downloadValue === "string") {
+          const url = downloadValue;
+          const a = document.createElement("a");
+          a.href = url;
+          a.download = "";
+          document.body.appendChild(a);
+          a.click();
+          document.body.removeChild(a);
+          const downloadId = `download_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+          const filename = url.split("/").pop() || "download";
+          const downloadInfo = {
+            downloadId,
+            filename,
+            url,
+            status: "pending"
+          };
+          return {
+            ...echo,
+            success: true,
+            download: downloadInfo
+          };
+        }
+        throw new ActionExecutionError(
+          'Action "download" requires either target_id (element to click) or value (URL to download)'
+        );
+      }
+      default:
+        throw new ActionExecutionError(
+          `Unknown action: "${action.action}" \u2014 must be one of VALID_ACTIONS (24 actions)`
+        );
+    }
+    return { ...echo, success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ...echo, success: false, error: message };
+  }
+}
+
+// src/index.ts
+var VSL_SDK_VERSION = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTION_TOOL_DESCRIPTION,
+  ACTION_TOOL_NAME,
+  ACTION_TOOL_SCHEMA,
+  ARIA_ROLE_TYPE_MAP,
+  ActionExecutionError,
+  AlibabaAdapter,
+  AnthropicAdapter,
+  LEVEL1_TAG_MAP,
+  LlmError,
+  LlmValidationError,
+  OpenAIAdapter,
+  VALID_ACTIONS,
+  VSL_SDK_VERSION,
+  VSL_VERSION,
+  VslSnapshotSession,
+  attachMutationObserver,
+  buildSystemPrompt,
+  buildUserPrompt,
+  buildVslDocument,
+  collectIds,
+  computeContentHash,
+  computeCoordHash,
+  createCacheStore,
+  diffVslDocuments,
+  executeAction,
+  extractDomTree,
+  isAriaHidden,
+  isVslDiff,
+  ownText,
+  resolveAriaRoleType,
+  resolveLevel1Type,
+  resolveSt,
+  resolveTarget,
+  retryWithBackoff,
+  segmentTree,
+  validateAction
+});
+//# sourceMappingURL=index.js.map