uilint-core 0.2.0 → 0.2.3

package/dist/node.js

@@ -35,7 +35,7 @@ import {
   truncateHTML,
   validateStyleGuide,
   validateViolations
-} from "./chunk-FIESH4VM.js";
+} from "./chunk-23BX6XC7.js";
 
 // src/logger.ts
 import pc from "picocolors";
@@ -92,7 +92,7 @@ import { spawn, spawnSync } from "child_process";
 import readline from "readline";
 var DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function isInteractiveTTY() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
@@ -102,11 +102,11 @@ async function promptYesNo(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return await new Promise((resolve) => {
+  return await new Promise((resolve2) => {
     rl.question(`${question} (y/N) `, (answer) => {
       rl.close();
       const normalized = (answer || "").trim().toLowerCase();
-      resolve(normalized === "y" || normalized === "yes");
+      resolve2(normalized === "y" || normalized === "yes");
     });
   });
 }
@@ -149,11 +149,11 @@ async function maybeInstallOllamaWithBrew() {
     "Ollama is not installed. Install with Homebrew now?"
   );
   if (!ok) return false;
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const child = spawn("brew", ["install", "ollama"], { stdio: "inherit" });
     child.on("error", reject);
     child.on("exit", (code) => {
-      if (code === 0) resolve();
+      if (code === 0) resolve2();
       else reject(new Error(`brew install ollama failed (exit ${code})`));
     });
   });
@@ -226,11 +226,11 @@ async function ensureOllamaModelPulled(options) {
   const baseUrl = options?.baseUrl || DEFAULT_OLLAMA_BASE_URL;
   const tags = await fetchOllamaTags(baseUrl);
   if (tags.includes(desired)) return;
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const child = spawn("ollama", ["pull", desired], { stdio: "inherit" });
     child.on("error", reject);
     child.on("exit", (code) => {
-      if (code === 0) resolve();
+      if (code === 0) resolve2();
       else reject(new Error(`ollama pull ${desired} failed (exit ${code})`));
     });
   });
@@ -295,11 +295,11 @@ function isJSON(str) {
 }
 async function readStdin() {
   const chunks = [];
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     process.stdin.on("data", (chunk) => {
       chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
     });
-    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
     process.stdin.on("error", reject);
   });
 }
@@ -481,10 +481,1493 @@ function addColorTokens(out, colors) {
     }
   }
 }
+
+// ../../node_modules/.pnpm/ollama@0.6.3/node_modules/ollama/dist/index.mjs
+import fs, { promises } from "fs";
+import { resolve } from "path";
+
+// ../../node_modules/.pnpm/whatwg-fetch@3.6.20/node_modules/whatwg-fetch/fetch.js
+var g = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || // eslint-disable-next-line no-undef
+typeof global !== "undefined" && global || {};
+var support = {
+  searchParams: "URLSearchParams" in g,
+  iterable: "Symbol" in g && "iterator" in Symbol,
+  blob: "FileReader" in g && "Blob" in g && (function() {
+    try {
+      new Blob();
+      return true;
+    } catch (e) {
+      return false;
+    }
+  })(),
+  formData: "FormData" in g,
+  arrayBuffer: "ArrayBuffer" in g
+};
+function isDataView(obj) {
+  return obj && DataView.prototype.isPrototypeOf(obj);
+}
+if (support.arrayBuffer) {
+  viewClasses = [
+    "[object Int8Array]",
+    "[object Uint8Array]",
+    "[object Uint8ClampedArray]",
+    "[object Int16Array]",
+    "[object Uint16Array]",
+    "[object Int32Array]",
+    "[object Uint32Array]",
+    "[object Float32Array]",
+    "[object Float64Array]"
+  ];
+  isArrayBufferView = ArrayBuffer.isView || function(obj) {
+    return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
+  };
+}
+var viewClasses;
+var isArrayBufferView;
+function normalizeName(name) {
+  if (typeof name !== "string") {
+    name = String(name);
+  }
+  if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "") {
+    throw new TypeError('Invalid character in header field name: "' + name + '"');
+  }
+  return name.toLowerCase();
+}
+function normalizeValue(value) {
+  if (typeof value !== "string") {
+    value = String(value);
+  }
+  return value;
+}
+function iteratorFor(items) {
+  var iterator = {
+    next: function() {
+      var value = items.shift();
+      return { done: value === void 0, value };
+    }
+  };
+  if (support.iterable) {
+    iterator[Symbol.iterator] = function() {
+      return iterator;
+    };
+  }
+  return iterator;
+}
+function Headers2(headers) {
+  this.map = {};
+  if (headers instanceof Headers2) {
+    headers.forEach(function(value, name) {
+      this.append(name, value);
+    }, this);
+  } else if (Array.isArray(headers)) {
+    headers.forEach(function(header) {
+      if (header.length != 2) {
+        throw new TypeError("Headers constructor: expected name/value pair to be length 2, found" + header.length);
+      }
+      this.append(header[0], header[1]);
+    }, this);
+  } else if (headers) {
+    Object.getOwnPropertyNames(headers).forEach(function(name) {
+      this.append(name, headers[name]);
+    }, this);
+  }
+}
+Headers2.prototype.append = function(name, value) {
+  name = normalizeName(name);
+  value = normalizeValue(value);
+  var oldValue = this.map[name];
+  this.map[name] = oldValue ? oldValue + ", " + value : value;
+};
+Headers2.prototype["delete"] = function(name) {
+  delete this.map[normalizeName(name)];
+};
+Headers2.prototype.get = function(name) {
+  name = normalizeName(name);
+  return this.has(name) ? this.map[name] : null;
+};
+Headers2.prototype.has = function(name) {
+  return this.map.hasOwnProperty(normalizeName(name));
+};
+Headers2.prototype.set = function(name, value) {
+  this.map[normalizeName(name)] = normalizeValue(value);
+};
+Headers2.prototype.forEach = function(callback, thisArg) {
+  for (var name in this.map) {
+    if (this.map.hasOwnProperty(name)) {
+      callback.call(thisArg, this.map[name], name, this);
+    }
+  }
+};
+Headers2.prototype.keys = function() {
+  var items = [];
+  this.forEach(function(value, name) {
+    items.push(name);
+  });
+  return iteratorFor(items);
+};
+Headers2.prototype.values = function() {
+  var items = [];
+  this.forEach(function(value) {
+    items.push(value);
+  });
+  return iteratorFor(items);
+};
+Headers2.prototype.entries = function() {
+  var items = [];
+  this.forEach(function(value, name) {
+    items.push([name, value]);
+  });
+  return iteratorFor(items);
+};
+if (support.iterable) {
+  Headers2.prototype[Symbol.iterator] = Headers2.prototype.entries;
+}
+function consumed(body) {
+  if (body._noBody) return;
+  if (body.bodyUsed) {
+    return Promise.reject(new TypeError("Already read"));
+  }
+  body.bodyUsed = true;
+}
+function fileReaderReady(reader) {
+  return new Promise(function(resolve2, reject) {
+    reader.onload = function() {
+      resolve2(reader.result);
+    };
+    reader.onerror = function() {
+      reject(reader.error);
+    };
+  });
+}
+function readBlobAsArrayBuffer(blob) {
+  var reader = new FileReader();
+  var promise = fileReaderReady(reader);
+  reader.readAsArrayBuffer(blob);
+  return promise;
+}
+function readBlobAsText(blob) {
+  var reader = new FileReader();
+  var promise = fileReaderReady(reader);
+  var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
+  var encoding = match ? match[1] : "utf-8";
+  reader.readAsText(blob, encoding);
+  return promise;
+}
+function readArrayBufferAsText(buf) {
+  var view = new Uint8Array(buf);
+  var chars = new Array(view.length);
+  for (var i = 0; i < view.length; i++) {
+    chars[i] = String.fromCharCode(view[i]);
+  }
+  return chars.join("");
+}
+function bufferClone(buf) {
+  if (buf.slice) {
+    return buf.slice(0);
+  } else {
+    var view = new Uint8Array(buf.byteLength);
+    view.set(new Uint8Array(buf));
+    return view.buffer;
+  }
+}
+function Body() {
+  this.bodyUsed = false;
+  this._initBody = function(body) {
+    this.bodyUsed = this.bodyUsed;
+    this._bodyInit = body;
+    if (!body) {
+      this._noBody = true;
+      this._bodyText = "";
+    } else if (typeof body === "string") {
+      this._bodyText = body;
+    } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+      this._bodyBlob = body;
+    } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+      this._bodyFormData = body;
+    } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+      this._bodyText = body.toString();
+    } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+      this._bodyArrayBuffer = bufferClone(body.buffer);
+      this._bodyInit = new Blob([this._bodyArrayBuffer]);
+    } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+      this._bodyArrayBuffer = bufferClone(body);
+    } else {
+      this._bodyText = body = Object.prototype.toString.call(body);
+    }
+    if (!this.headers.get("content-type")) {
+      if (typeof body === "string") {
+        this.headers.set("content-type", "text/plain;charset=UTF-8");
+      } else if (this._bodyBlob && this._bodyBlob.type) {
+        this.headers.set("content-type", this._bodyBlob.type);
+      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+        this.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+      }
+    }
+  };
+  if (support.blob) {
+    this.blob = function() {
+      var rejected = consumed(this);
+      if (rejected) {
+        return rejected;
+      }
+      if (this._bodyBlob) {
+        return Promise.resolve(this._bodyBlob);
+      } else if (this._bodyArrayBuffer) {
+        return Promise.resolve(new Blob([this._bodyArrayBuffer]));
+      } else if (this._bodyFormData) {
+        throw new Error("could not read FormData body as blob");
+      } else {
+        return Promise.resolve(new Blob([this._bodyText]));
+      }
+    };
+  }
+  this.arrayBuffer = function() {
+    if (this._bodyArrayBuffer) {
+      var isConsumed = consumed(this);
+      if (isConsumed) {
+        return isConsumed;
+      } else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+        return Promise.resolve(
+          this._bodyArrayBuffer.buffer.slice(
+            this._bodyArrayBuffer.byteOffset,
+            this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+          )
+        );
+      } else {
+        return Promise.resolve(this._bodyArrayBuffer);
+      }
+    } else if (support.blob) {
+      return this.blob().then(readBlobAsArrayBuffer);
+    } else {
+      throw new Error("could not read as ArrayBuffer");
+    }
+  };
+  this.text = function() {
+    var rejected = consumed(this);
+    if (rejected) {
+      return rejected;
+    }
+    if (this._bodyBlob) {
+      return readBlobAsText(this._bodyBlob);
+    } else if (this._bodyArrayBuffer) {
+      return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
+    } else if (this._bodyFormData) {
+      throw new Error("could not read FormData body as text");
+    } else {
+      return Promise.resolve(this._bodyText);
+    }
+  };
+  if (support.formData) {
+    this.formData = function() {
+      return this.text().then(decode);
+    };
+  }
+  this.json = function() {
+    return this.text().then(JSON.parse);
+  };
+  return this;
+}
+var methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
+function normalizeMethod(method) {
+  var upcased = method.toUpperCase();
+  return methods.indexOf(upcased) > -1 ? upcased : method;
+}
+function Request(input, options) {
+  if (!(this instanceof Request)) {
+    throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+  }
+  options = options || {};
+  var body = options.body;
+  if (input instanceof Request) {
+    if (input.bodyUsed) {
+      throw new TypeError("Already read");
+    }
+    this.url = input.url;
+    this.credentials = input.credentials;
+    if (!options.headers) {
+      this.headers = new Headers2(input.headers);
+    }
+    this.method = input.method;
+    this.mode = input.mode;
+    this.signal = input.signal;
+    if (!body && input._bodyInit != null) {
+      body = input._bodyInit;
+      input.bodyUsed = true;
+    }
+  } else {
+    this.url = String(input);
+  }
+  this.credentials = options.credentials || this.credentials || "same-origin";
+  if (options.headers || !this.headers) {
+    this.headers = new Headers2(options.headers);
+  }
+  this.method = normalizeMethod(options.method || this.method || "GET");
+  this.mode = options.mode || this.mode || null;
+  this.signal = options.signal || this.signal || (function() {
+    if ("AbortController" in g) {
+      var ctrl = new AbortController();
+      return ctrl.signal;
+    }
+  })();
+  this.referrer = null;
+  if ((this.method === "GET" || this.method === "HEAD") && body) {
+    throw new TypeError("Body not allowed for GET or HEAD requests");
+  }
+  this._initBody(body);
+  if (this.method === "GET" || this.method === "HEAD") {
+    if (options.cache === "no-store" || options.cache === "no-cache") {
+      var reParamSearch = /([?&])_=[^&]*/;
+      if (reParamSearch.test(this.url)) {
+        this.url = this.url.replace(reParamSearch, "$1_=" + (/* @__PURE__ */ new Date()).getTime());
+      } else {
+        var reQueryString = /\?/;
+        this.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (/* @__PURE__ */ new Date()).getTime();
+      }
+    }
+  }
+}
+Request.prototype.clone = function() {
+  return new Request(this, { body: this._bodyInit });
+};
+function decode(body) {
+  var form = new FormData();
+  body.trim().split("&").forEach(function(bytes) {
+    if (bytes) {
+      var split = bytes.split("=");
+      var name = split.shift().replace(/\+/g, " ");
+      var value = split.join("=").replace(/\+/g, " ");
+      form.append(decodeURIComponent(name), decodeURIComponent(value));
+    }
+  });
+  return form;
+}
+function parseHeaders(rawHeaders) {
+  var headers = new Headers2();
+  var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
+  preProcessedHeaders.split("\r").map(function(header) {
+    return header.indexOf("\n") === 0 ? header.substr(1, header.length) : header;
+  }).forEach(function(line) {
+    var parts = line.split(":");
+    var key = parts.shift().trim();
+    if (key) {
+      var value = parts.join(":").trim();
+      try {
+        headers.append(key, value);
+      } catch (error) {
+        console.warn("Response " + error.message);
+      }
+    }
+  });
+  return headers;
+}
+Body.call(Request.prototype);
+function Response(bodyInit, options) {
+  if (!(this instanceof Response)) {
+    throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+  }
+  if (!options) {
+    options = {};
+  }
+  this.type = "default";
+  this.status = options.status === void 0 ? 200 : options.status;
+  if (this.status < 200 || this.status > 599) {
+    throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].");
+  }
+  this.ok = this.status >= 200 && this.status < 300;
+  this.statusText = options.statusText === void 0 ? "" : "" + options.statusText;
+  this.headers = new Headers2(options.headers);
+  this.url = options.url || "";
+  this._initBody(bodyInit);
+}
+Body.call(Response.prototype);
+Response.prototype.clone = function() {
+  return new Response(this._bodyInit, {
+    status: this.status,
+    statusText: this.statusText,
+    headers: new Headers2(this.headers),
+    url: this.url
+  });
+};
+Response.error = function() {
+  var response = new Response(null, { status: 200, statusText: "" });
+  response.ok = false;
+  response.status = 0;
+  response.type = "error";
+  return response;
+};
+var redirectStatuses = [301, 302, 303, 307, 308];
+Response.redirect = function(url, status) {
+  if (redirectStatuses.indexOf(status) === -1) {
+    throw new RangeError("Invalid status code");
+  }
+  return new Response(null, { status, headers: { location: url } });
+};
+var DOMException = g.DOMException;
+try {
+  new DOMException();
+} catch (err) {
+  DOMException = function(message, name) {
+    this.message = message;
+    this.name = name;
+    var error = Error(message);
+    this.stack = error.stack;
+  };
+  DOMException.prototype = Object.create(Error.prototype);
+  DOMException.prototype.constructor = DOMException;
+}
+function fetch2(input, init) {
+  return new Promise(function(resolve2, reject) {
+    var request = new Request(input, init);
+    if (request.signal && request.signal.aborted) {
+      return reject(new DOMException("Aborted", "AbortError"));
+    }
+    var xhr = new XMLHttpRequest();
+    function abortXhr() {
+      xhr.abort();
+    }
+    xhr.onload = function() {
+      var options = {
+        statusText: xhr.statusText,
+        headers: parseHeaders(xhr.getAllResponseHeaders() || "")
+      };
+      if (request.url.indexOf("file://") === 0 && (xhr.status < 200 || xhr.status > 599)) {
+        options.status = 200;
+      } else {
+        options.status = xhr.status;
+      }
+      options.url = "responseURL" in xhr ? xhr.responseURL : options.headers.get("X-Request-URL");
+      var body = "response" in xhr ? xhr.response : xhr.responseText;
+      setTimeout(function() {
+        resolve2(new Response(body, options));
+      }, 0);
+    };
+    xhr.onerror = function() {
+      setTimeout(function() {
+        reject(new TypeError("Network request failed"));
+      }, 0);
+    };
+    xhr.ontimeout = function() {
+      setTimeout(function() {
+        reject(new TypeError("Network request timed out"));
+      }, 0);
+    };
+    xhr.onabort = function() {
+      setTimeout(function() {
+        reject(new DOMException("Aborted", "AbortError"));
+      }, 0);
+    };
+    function fixUrl(url) {
+      try {
+        return url === "" && g.location.href ? g.location.href : url;
+      } catch (e) {
+        return url;
+      }
+    }
+    xhr.open(request.method, fixUrl(request.url), true);
+    if (request.credentials === "include") {
+      xhr.withCredentials = true;
+    } else if (request.credentials === "omit") {
+      xhr.withCredentials = false;
+    }
+    if ("responseType" in xhr) {
+      if (support.blob) {
+        xhr.responseType = "blob";
+      } else if (support.arrayBuffer) {
+        xhr.responseType = "arraybuffer";
+      }
+    }
+    if (init && typeof init.headers === "object" && !(init.headers instanceof Headers2 || g.Headers && init.headers instanceof g.Headers)) {
+      var names = [];
+      Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+        names.push(normalizeName(name));
+        xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+      });
+      request.headers.forEach(function(value, name) {
+        if (names.indexOf(name) === -1) {
+          xhr.setRequestHeader(name, value);
+        }
+      });
+    } else {
+      request.headers.forEach(function(value, name) {
+        xhr.setRequestHeader(name, value);
+      });
+    }
+    if (request.signal) {
+      request.signal.addEventListener("abort", abortXhr);
+      xhr.onreadystatechange = function() {
+        if (xhr.readyState === 4) {
+          request.signal.removeEventListener("abort", abortXhr);
+        }
+      };
+    }
+    xhr.send(typeof request._bodyInit === "undefined" ? null : request._bodyInit);
+  });
+}
+fetch2.polyfill = true;
+if (!g.fetch) {
+  g.fetch = fetch2;
+  g.Headers = Headers2;
+  g.Request = Request;
+  g.Response = Response;
+}
+
+// ../../node_modules/.pnpm/ollama@0.6.3/node_modules/ollama/dist/browser.mjs
+var defaultPort = "11434";
+var defaultHost = `http://127.0.0.1:${defaultPort}`;
+var version = "0.6.3";
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var ResponseError = class _ResponseError extends Error {
+  constructor(error, status_code) {
+    super(error);
+    this.error = error;
+    this.status_code = status_code;
+    this.name = "ResponseError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ResponseError);
+    }
+  }
+};
+var AbortableAsyncIterator = class {
+  constructor(abortController, itr, doneCallback) {
+    __publicField$1(this, "abortController");
+    __publicField$1(this, "itr");
+    __publicField$1(this, "doneCallback");
+    this.abortController = abortController;
+    this.itr = itr;
+    this.doneCallback = doneCallback;
+  }
+  abort() {
+    this.abortController.abort();
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const message of this.itr) {
+      if ("error" in message) {
+        throw new Error(message.error);
+      }
+      yield message;
+      if (message.done || message.status === "success") {
+        this.doneCallback();
+        return;
+      }
+    }
+    throw new Error("Did not receive done or success response in stream.");
+  }
+};
+var checkOk = async (response) => {
+  if (response.ok) {
+    return;
+  }
+  let message = `Error ${response.status}: ${response.statusText}`;
+  let errorData = null;
+  if (response.headers.get("content-type")?.includes("application/json")) {
+    try {
+      errorData = await response.json();
+      message = errorData.error || message;
+    } catch (error) {
+      console.log("Failed to parse error response as JSON");
+    }
+  } else {
+    try {
+      console.log("Getting text from response");
+      const textResponse = await response.text();
+      message = textResponse || message;
+    } catch (error) {
+      console.log("Failed to get text from error response");
+    }
+  }
+  throw new ResponseError(message, response.status);
+};
+function getPlatform() {
+  if (typeof window !== "undefined" && window.navigator) {
+    const nav = navigator;
+    if ("userAgentData" in nav && nav.userAgentData?.platform) {
+      return `${nav.userAgentData.platform.toLowerCase()} Browser/${navigator.userAgent};`;
+    }
+    if (navigator.platform) {
+      return `${navigator.platform.toLowerCase()} Browser/${navigator.userAgent};`;
+    }
+    return `unknown Browser/${navigator.userAgent};`;
+  } else if (typeof process !== "undefined") {
+    return `${process.arch} ${process.platform} Node.js/${process.version}`;
+  }
+  return "";
+}
+function normalizeHeaders(headers) {
+  if (headers instanceof Headers) {
+    const obj = {};
+    headers.forEach((value, key) => {
+      obj[key] = value;
+    });
+    return obj;
+  } else if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  } else {
+    return headers || {};
+  }
+}
+var readEnvVar = (obj, key) => {
+  return obj[key];
+};
+var fetchWithHeaders = async (fetch3, url, options = {}) => {
+  const defaultHeaders = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "User-Agent": `ollama-js/${version} (${getPlatform()})`
+  };
+  options.headers = normalizeHeaders(options.headers);
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "https:" && parsed.hostname === "ollama.com") {
+      const apiKey = typeof process === "object" && process !== null && typeof process.env === "object" && process.env !== null ? readEnvVar(process.env, "OLLAMA_API_KEY") : void 0;
+      const authorization = options.headers["authorization"] || options.headers["Authorization"];
+      if (!authorization && apiKey) {
+        options.headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+    }
+  } catch (error) {
+    console.error("error parsing url", error);
+  }
+  const customHeaders = Object.fromEntries(
+    Object.entries(options.headers).filter(
+      ([key]) => !Object.keys(defaultHeaders).some(
+        (defaultKey) => defaultKey.toLowerCase() === key.toLowerCase()
+      )
+    )
+  );
+  options.headers = {
+    ...defaultHeaders,
+    ...customHeaders
+  };
+  return fetch3(url, options);
+};
+var get = async (fetch3, host, options) => {
+  const response = await fetchWithHeaders(fetch3, host, {
+    headers: options?.headers
+  });
+  await checkOk(response);
+  return response;
+};
+var post = async (fetch3, host, data, options) => {
+  const isRecord = (input) => {
+    return input !== null && typeof input === "object" && !Array.isArray(input);
+  };
+  const formattedData = isRecord(data) ? JSON.stringify(data) : data;
+  const response = await fetchWithHeaders(fetch3, host, {
+    method: "POST",
+    body: formattedData,
+    signal: options?.signal,
+    headers: options?.headers
+  });
+  await checkOk(response);
+  return response;
+};
+var del = async (fetch3, host, data, options) => {
+  const response = await fetchWithHeaders(fetch3, host, {
+    method: "DELETE",
+    body: JSON.stringify(data),
+    headers: options?.headers
+  });
+  await checkOk(response);
+  return response;
+};
+var parseJSON = async function* (itr) {
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  const reader = itr.getReader();
+  while (true) {
+    const { done, value: chunk } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(chunk, { stream: true });
+    const parts = buffer.split("\n");
+    buffer = parts.pop() ?? "";
+    for (const part of parts) {
+      try {
+        yield JSON.parse(part);
+      } catch (error) {
+        console.warn("invalid json: ", part);
+      }
+    }
+  }
+  buffer += decoder.decode();
+  for (const part of buffer.split("\n").filter((p) => p !== "")) {
+    try {
+      yield JSON.parse(part);
+    } catch (error) {
+      console.warn("invalid json: ", part);
+    }
+  }
+};
+var formatHost = (host) => {
+  if (!host) {
+    return defaultHost;
+  }
+  let isExplicitProtocol = host.includes("://");
+  if (host.startsWith(":")) {
+    host = `http://127.0.0.1${host}`;
+    isExplicitProtocol = true;
+  }
+  if (!isExplicitProtocol) {
+    host = `http://${host}`;
+  }
+  const url = new URL(host);
+  let port = url.port;
+  if (!port) {
+    if (!isExplicitProtocol) {
+      port = defaultPort;
+    } else {
+      port = url.protocol === "https:" ? "443" : "80";
+    }
+  }
+  let auth = "";
+  if (url.username) {
+    auth = url.username;
+    if (url.password) {
+      auth += `:${url.password}`;
+    }
+    auth += "@";
+  }
+  let formattedHost = `${url.protocol}//${auth}${url.hostname}:${port}${url.pathname}`;
+  if (formattedHost.endsWith("/")) {
+    formattedHost = formattedHost.slice(0, -1);
+  }
+  return formattedHost;
+};
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var Ollama$1 = class Ollama {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "fetch");
+    __publicField(this, "ongoingStreamedRequests", []);
+    this.config = {
+      host: "",
+      headers: config?.headers
+    };
+    if (!config?.proxy) {
+      this.config.host = formatHost(config?.host ?? defaultHost);
+    }
+    this.fetch = config?.fetch ?? fetch;
+  }
+  // Abort any ongoing streamed requests to Ollama
+  abort() {
+    for (const request of this.ongoingStreamedRequests) {
+      request.abort();
+    }
+    this.ongoingStreamedRequests.length = 0;
+  }
+  /**
+   * Processes a request to the Ollama server. If the request is streamable, it will return a
+   * AbortableAsyncIterator that yields the response messages. Otherwise, it will return the response
+   * object.
+   * @param endpoint {string} - The endpoint to send the request to.
+   * @param request {object} - The request object to send to the endpoint.
+   * @protected {T | AbortableAsyncIterator<T>} - The response object or a AbortableAsyncIterator that yields
+   * response messages.
+   * @throws {Error} - If the response body is missing or if the response is an error.
+   * @returns {Promise<T | AbortableAsyncIterator<T>>} - The response object or a AbortableAsyncIterator that yields the streamed response.
+   */
+  async processStreamableRequest(endpoint, request) {
+    request.stream = request.stream ?? false;
+    const host = `${this.config.host}/api/${endpoint}`;
+    if (request.stream) {
+      const abortController = new AbortController();
+      const response2 = await post(this.fetch, host, request, {
+        signal: abortController.signal,
+        headers: this.config.headers
+      });
+      if (!response2.body) {
+        throw new Error("Missing body");
+      }
+      const itr = parseJSON(response2.body);
+      const abortableAsyncIterator = new AbortableAsyncIterator(
+        abortController,
+        itr,
+        () => {
+          const i = this.ongoingStreamedRequests.indexOf(abortableAsyncIterator);
+          if (i > -1) {
+            this.ongoingStreamedRequests.splice(i, 1);
+          }
+        }
+      );
+      this.ongoingStreamedRequests.push(abortableAsyncIterator);
+      return abortableAsyncIterator;
+    }
+    const response = await post(this.fetch, host, request, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Encodes an image to base64 if it is a Uint8Array.
+   * @param image {Uint8Array | string} - The image to encode.
+   * @returns {Promise<string>} - The base64 encoded image.
+   */
+  async encodeImage(image) {
+    if (typeof image !== "string") {
+      const uint8Array = new Uint8Array(image);
+      let byteString = "";
+      const len = uint8Array.byteLength;
+      for (let i = 0; i < len; i++) {
+        byteString += String.fromCharCode(uint8Array[i]);
+      }
+      return btoa(byteString);
+    }
+    return image;
+  }
+  /**
+   * Generates a response from a text prompt.
+   * @param request {GenerateRequest} - The request object.
+   * @returns {Promise<GenerateResponse | AbortableAsyncIterator<GenerateResponse>>} - The response object or
+   * an AbortableAsyncIterator that yields response messages.
+   */
+  async generate(request) {
+    if (request.images) {
+      request.images = await Promise.all(request.images.map(this.encodeImage.bind(this)));
+    }
+    return this.processStreamableRequest("generate", request);
+  }
+  /**
+   * Chats with the model. The request object can contain messages with images that are either
+   * Uint8Arrays or base64 encoded strings. The images will be base64 encoded before sending the
+   * request.
+   * @param request {ChatRequest} - The request object.
+   * @returns {Promise<ChatResponse | AbortableAsyncIterator<ChatResponse>>} - The response object or an
+   * AbortableAsyncIterator that yields response messages.
+   */
+  async chat(request) {
+    if (request.messages) {
+      for (const message of request.messages) {
+        if (message.images) {
+          message.images = await Promise.all(
+            message.images.map(this.encodeImage.bind(this))
+          );
+        }
+      }
+    }
+    return this.processStreamableRequest("chat", request);
+  }
+  /**
+   * Creates a new model from a stream of data.
+   * @param request {CreateRequest} - The request object.
+   * @returns {Promise<ProgressResponse | AbortableAsyncIterator<ProgressResponse>>} - The response object or a stream of progress responses.
+   */
+  async create(request) {
+    return this.processStreamableRequest("create", {
+      ...request
+    });
+  }
+  /**
+   * Pulls a model from the Ollama registry. The request object can contain a stream flag to indicate if the
+   * response should be streamed.
+   * @param request {PullRequest} - The request object.
+   * @returns {Promise<ProgressResponse | AbortableAsyncIterator<ProgressResponse>>} - The response object or
+   * an AbortableAsyncIterator that yields response messages.
+   */
+  async pull(request) {
+    return this.processStreamableRequest("pull", {
+      name: request.model,
+      stream: request.stream,
+      insecure: request.insecure
+    });
+  }
+  /**
+   * Pushes a model to the Ollama registry. The request object can contain a stream flag to indicate if the
+   * response should be streamed.
+   * @param request {PushRequest} - The request object.
+   * @returns {Promise<ProgressResponse | AbortableAsyncIterator<ProgressResponse>>} - The response object or
+   * an AbortableAsyncIterator that yields response messages.
+   */
+  async push(request) {
+    return this.processStreamableRequest("push", {
+      name: request.model,
+      stream: request.stream,
+      insecure: request.insecure
+    });
+  }
+  /**
+   * Deletes a model from the server. The request object should contain the name of the model to
+   * delete.
+   * @param request {DeleteRequest} - The request object.
+   * @returns {Promise<StatusResponse>} - The response object.
+   */
+  async delete(request) {
+    await del(
+      this.fetch,
+      `${this.config.host}/api/delete`,
+      { name: request.model },
+      { headers: this.config.headers }
+    );
+    return { status: "success" };
+  }
+  /**
+   * Copies a model from one name to another. The request object should contain the name of the
+   * model to copy and the new name.
+   * @param request {CopyRequest} - The request object.
+   * @returns {Promise<StatusResponse>} - The response object.
+   */
+  async copy(request) {
+    await post(this.fetch, `${this.config.host}/api/copy`, { ...request }, {
+      headers: this.config.headers
+    });
+    return { status: "success" };
+  }
+  /**
+   * Lists the models on the server.
+   * @returns {Promise<ListResponse>} - The response object.
+   * @throws {Error} - If the response body is missing.
+   */
+  async list() {
+    const response = await get(this.fetch, `${this.config.host}/api/tags`, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Shows the metadata of a model. The request object should contain the name of the model.
+   * @param request {ShowRequest} - The request object.
+   * @returns {Promise<ShowResponse>} - The response object.
+   */
+  async show(request) {
+    const response = await post(this.fetch, `${this.config.host}/api/show`, {
+      ...request
+    }, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Embeds text input into vectors.
+   * @param request {EmbedRequest} - The request object.
+   * @returns {Promise<EmbedResponse>} - The response object.
+   */
+  async embed(request) {
+    const response = await post(this.fetch, `${this.config.host}/api/embed`, {
+      ...request
+    }, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Embeds a text prompt into a vector.
+   * @param request {EmbeddingsRequest} - The request object.
+   * @returns {Promise<EmbeddingsResponse>} - The response object.
+   */
+  async embeddings(request) {
+    const response = await post(this.fetch, `${this.config.host}/api/embeddings`, {
+      ...request
+    }, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Lists the running models on the server
+   * @returns {Promise<ListResponse>} - The response object.
+   * @throws {Error} - If the response body is missing.
+   */
+  async ps() {
+    const response = await get(this.fetch, `${this.config.host}/api/ps`, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Returns the Ollama server version.
+   * @returns {Promise<VersionResponse>} - The server version object.
+   */
+  async version() {
+    const response = await get(this.fetch, `${this.config.host}/api/version`, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Performs web search using the Ollama web search API
+   * @param request {WebSearchRequest} - The search request containing query and options
+   * @returns {Promise<WebSearchResponse>} - The search results
+   * @throws {Error} - If the request is invalid or the server returns an error
+   */
+  async webSearch(request) {
+    if (!request.query || request.query.length === 0) {
+      throw new Error("Query is required");
+    }
+    const response = await post(this.fetch, `https://ollama.com/api/web_search`, { ...request }, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Fetches a single page using the Ollama web fetch API
+   * @param request {WebFetchRequest} - The fetch request containing a URL
+   * @returns {Promise<WebFetchResponse>} - The fetch result
+   * @throws {Error} - If the request is invalid or the server returns an error
+   */
+  async webFetch(request) {
+    if (!request.url || request.url.length === 0) {
+      throw new Error("URL is required");
+    }
+    const response = await post(this.fetch, `https://ollama.com/api/web_fetch`, { ...request }, { headers: this.config.headers });
+    return await response.json();
+  }
+};
+var browser = new Ollama$1();
+
+// ../../node_modules/.pnpm/ollama@0.6.3/node_modules/ollama/dist/index.mjs
+var Ollama2 = class extends Ollama$1 {
+  async encodeImage(image) {
+    if (typeof image !== "string") {
+      return Buffer.from(image).toString("base64");
+    }
+    try {
+      if (fs.existsSync(image)) {
+        const fileBuffer = await promises.readFile(resolve(image));
+        return Buffer.from(fileBuffer).toString("base64");
+      }
+    } catch {
+    }
+    return image;
+  }
+  /**
+   * checks if a file exists
+   * @param path {string} - The path to the file
+   * @private @internal
+   * @returns {Promise<boolean>} - Whether the file exists or not
+   */
+  async fileExists(path) {
+    try {
+      await promises.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async create(request) {
+    if (request.from && await this.fileExists(resolve(request.from))) {
+      throw Error("Creating with a local path is not currently supported from ollama-js");
+    }
+    if (request.stream) {
+      return super.create(request);
+    } else {
+      return super.create(request);
+    }
+  }
+};
+var index = new Ollama2();
+
+// src/scanner/vision-analyzer.ts
+var UILINT_DEFAULT_VISION_MODEL = "qwen3-vl:8b-instruct";
+function stripCodeFences(input) {
+  const trimmed = (input ?? "").trim();
+  if (!trimmed.startsWith("```")) return trimmed;
+  const m = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  return m ? m[1].trim() : trimmed;
+}
+function extractJsonObject(input) {
+  const s = stripCodeFences(input).trim();
+  if (!s) return s;
+  if (s.startsWith("{") && s.endsWith("}")) return s;
+  const start = s.indexOf("{");
+  const end = s.lastIndexOf("}");
+  if (start !== -1 && end !== -1 && end > start) {
+    return s.slice(start, end + 1).trim();
+  }
+  return s;
+}
+var DEFAULT_BASE_URL = "http://localhost:11434";
+var DEFAULT_TIMEOUT = 12e4;
+var VisionAnalyzer = class {
+  baseUrl;
+  visionModel;
+  timeout;
+  instrumentation;
+  client;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || DEFAULT_BASE_URL;
+    this.visionModel = options.visionModel || UILINT_DEFAULT_VISION_MODEL;
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+    this.instrumentation = options.instrumentation;
+    this.client = new Ollama2({ host: this.baseUrl });
+  }
+  /**
+   * Analyzes a screenshot with element manifest for UI consistency issues
+   */
+  async analyzeScreenshot(imageBase64, manifest, options = {}) {
+    const startTime = Date.now();
+    const prompt = this.buildVisionPrompt(manifest, options);
+    const spanResult = this.instrumentation?.onGenerationStart?.({
+      name: "vision-analyze",
+      model: this.visionModel,
+      prompt,
+      metadata: {
+        manifestSize: manifest.length,
+        hasStyleGuide: !!options.styleGuide
+      }
+    });
+    const span = spanResult || void 0;
+    try {
+      const rawResponse = options.onProgress ? await this.chatVisionStreaming(
+        imageBase64,
+        prompt,
+        options.onProgress,
+        span
+      ) : await this.chatVision(imageBase64, prompt, span);
+      const issues = this.parseVisionResponse(rawResponse, manifest);
+      return {
+        issues,
+        analysisTime: Date.now() - startTime,
+        prompt,
+        rawResponse
+      };
+    } catch (error) {
+      const analysisTime = Date.now() - startTime;
+      const err = error instanceof Error ? error : new Error(String(error ?? "Unknown error"));
+      console.error("[VisionAnalyzer] Analysis failed", {
+        baseUrl: this.baseUrl,
+        model: this.visionModel,
+        manifestSize: manifest.length,
+        analysisTime,
+        error: err.message
+      });
+      span?.end("", { error: err.message });
+      throw err;
+    }
+  }
+  /**
+   * Builds the vision analysis prompt
+   */
+  buildVisionPrompt(manifest, options) {
+    const styleGuideSection = options.styleGuide ? `## Style Guide
+${options.styleGuide}
+
+` : "";
+    const additionalSection = options.additionalContext ? `## Additional Context
+${options.additionalContext}
+
+` : "";
+    const manifestSection = this.buildManifestSection(manifest);
+    return `You are a UI consistency analyzer examining a screenshot of a web page.
+Analyze the visual appearance and identify any UI consistency issues.
+
+${styleGuideSection}${additionalSection}${manifestSection}
+
+## Task
+
+Examine the screenshot and identify visual consistency issues such as:
+1. **Spacing inconsistencies**: Elements with uneven padding, margins, or gaps
+2. **Alignment issues**: Elements that should be aligned but aren't
+3. **Color inconsistencies**: Similar colors that should be identical, or colors that don't match the style guide
+4. **Typography issues**: Inconsistent font sizes, weights, or families
+5. **Layout problems**: Broken layouts, overlapping elements, or visual hierarchy issues
+6. **Contrast issues**: Text that's hard to read or UI elements with insufficient contrast
+
+For each issue found, reference the element by its visible text so we can map it back to the source code.
+
+## Response Format
+
+Respond with JSON ONLY. Return a single JSON object:
+
+\`\`\`json
+{
+  "issues": [
+    {
+      "elementText": "Submit Order",
+      "message": "Button has inconsistent padding compared to other buttons (appears larger)",
+      "category": "spacing",
+      "severity": "warning"
+    }
+  ]
+}
+\`\`\`
+
+Categories: spacing, alignment, color, typography, layout, contrast, visual-hierarchy
+Severities: error (major issue), warning (should fix), info (minor/suggestion)
+
+IMPORTANT:
+- Reference elements by their visible text content
+- Be specific about what's wrong and what the expected state should be
+- Only report significant visual inconsistencies
+- If no issues are found, return {"issues": []}`;
+  }
+  /**
+   * Builds the manifest section of the prompt
+   */
+  buildManifestSection(manifest) {
+    if (manifest.length === 0) {
+      return "";
+    }
+    const elements = manifest.map((el) => {
+      const parts = [`- "${el.text}"`];
+      if (el.role) parts.push(`(${el.role})`);
+      if (el.instanceCount && el.instanceCount > 1) {
+        parts.push(`[${el.instanceCount} instances]`);
+      }
+      return parts.join(" ");
+    });
+    return `## Page Elements
+
+The following elements are visible on the page (reference by text when reporting issues):
+
+${elements.join("\n")}
+
+`;
+  }
+  /**
+   * Non-streaming chat API call for vision
+   */
+  async chatVision(imageBase64, prompt, span) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const base64Data = imageBase64.includes(",") ? imageBase64.split(",")[1] : imageBase64;
+      const response = await this.client.chat({
+        model: this.visionModel,
+        messages: [
+          {
+            role: "user",
+            content: prompt,
+            images: [base64Data]
+          }
+        ],
+        format: "json",
+        options: {
+          // Increase context window for large prompts
+          num_ctx: 8192
+        }
+      });
+      const output = response.message?.content || "";
+      if (!output.trim()) {
+        const diag = JSON.stringify(
+          {
+            done_reason: response.done_reason,
+            model: response.model,
+            prompt_eval_count: response.prompt_eval_count,
+            eval_count: response.eval_count
+          },
+          null,
+          2
+        );
+        const errorMsg = `Vision model returned empty output. Diagnostics: ${diag}`;
+        span?.end("", { error: errorMsg });
+        throw new Error(errorMsg);
+      }
+      span?.end(output, {
+        promptTokens: response.prompt_eval_count,
+        completionTokens: response.eval_count,
+        totalTokens: (response.prompt_eval_count || 0) + (response.eval_count || 0) || void 0
+      });
+      return output;
+    } catch (error) {
+      span?.end("", { error: String(error) });
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Streaming chat API call for vision
+   * Uses ollama package's async iterator for streaming
+   */
+  async chatVisionStreaming(imageBase64, prompt, onProgress, span) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    let promptTokens;
+    let completionTokens;
+    let chunksReceived = 0;
+    let lastProgressAt = Date.now();
+    let emittedWaitingLine = false;
+    try {
+      const base64Data = imageBase64.includes(",") ? imageBase64.split(",")[1] : imageBase64;
+      const stream = await this.client.chat({
+        model: this.visionModel,
+        messages: [
+          {
+            role: "user",
+            content: prompt,
+            images: [base64Data]
+          }
+        ],
+        // Enable thinking for streaming so we can surface reasoning traces for thinking-capable models.
+        // Models that don't support it should ignore it.
+        think: false,
+        stream: true,
+        format: "json",
+        options: {
+          num_ctx: 8192
+        }
+      });
+      let fullResponse = "";
+      let lastLatestLine = "";
+      for await (const chunk of stream) {
+        chunksReceived++;
+        if (!emittedWaitingLine && !fullResponse.trim()) {
+          onProgress("(waiting for model output\u2026)", fullResponse);
+          emittedWaitingLine = true;
+        }
+        const thinking = chunk?.message?.thinking || "";
+        if (thinking) {
+          onProgress(lastLatestLine, fullResponse, void 0, thinking);
+          lastProgressAt = Date.now();
+        }
+        const content = chunk.message?.content || "";
+        if (content) {
+          fullResponse += content;
+          const responseLines = fullResponse.split("\n");
+          const latestLine = responseLines[responseLines.length - 1] || responseLines[responseLines.length - 2] || "";
+          lastLatestLine = latestLine.trim();
+          onProgress(lastLatestLine, fullResponse, content);
+          lastProgressAt = Date.now();
+        }
+        if (chunk.done) {
+          promptTokens = chunk.prompt_eval_count;
+          completionTokens = chunk.eval_count;
+        }
+        if (!fullResponse.trim() && Date.now() - lastProgressAt > 4e3) {
+          onProgress(
+            `(streaming\u2026 received ${chunksReceived} chunks)`,
+            fullResponse
+          );
+          lastProgressAt = Date.now();
+        }
+      }
+      if (!fullResponse.trim()) {
+        const diag = JSON.stringify(
+          {
+            chunksReceived,
+            promptTokens,
+            completionTokens,
+            model: this.visionModel
+          },
+          null,
+          2
+        );
+        const errorMsg = `Vision model returned empty output (streaming). Diagnostics: ${diag}`;
+        span?.end("", { error: errorMsg });
+        throw new Error(errorMsg);
+      }
+      span?.end(fullResponse, {
+        promptTokens,
+        completionTokens,
+        totalTokens: (promptTokens || 0) + (completionTokens || 0) || void 0
+      });
+      return fullResponse;
+    } catch (error) {
+      span?.end("", { error: String(error) });
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Parses the vision LLM response and matches elements to manifest
+   */
+  parseVisionResponse(response, manifest) {
+    try {
+      const jsonText = extractJsonObject(response);
+      const parsed = JSON.parse(jsonText);
+      const rawIssues = parsed.issues || [];
+      return rawIssues.map((issue) => {
+        const matchedElement = this.matchElementByText(
+          issue.elementText,
+          manifest
+        );
+        return {
+          ...issue,
+          dataLoc: matchedElement?.dataLoc
+        };
+      });
+    } catch {
+      const s = response ?? "";
+      const previewHead = s ? s.slice(0, 600) : "";
+      const previewTail = s && s.length > 600 ? s.slice(-400) : "";
+      throw new Error(
+        `Vision model returned non-JSON output (expected JSON). length=${s.length} head=${JSON.stringify(previewHead)} tail=${JSON.stringify(
+          previewTail
+        )}`
+      );
+    }
+  }
+  /**
+   * Matches element text from LLM response to manifest entries
+   */
+  matchElementByText(elementText, manifest) {
+    if (!elementText) return void 0;
+    const normalizedSearch = elementText.toLowerCase().trim();
+    for (const entry of manifest) {
+      if (entry.text.toLowerCase().trim() === normalizedSearch) {
+        return entry;
+      }
+    }
+    for (const entry of manifest) {
+      const normalizedEntry = entry.text.toLowerCase().trim();
+      if (normalizedEntry.includes(normalizedSearch) || normalizedSearch.includes(normalizedEntry)) {
+        return entry;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Checks if the vision model is available
+   */
+  async isAvailable() {
+    try {
+      const models = await this.client.list();
+      return models.models.some(
+        (m) => m.name === this.visionModel || m.name.startsWith(this.visionModel.split(":")[0])
+      );
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Gets the current vision model
+   */
+  getModel() {
+    return this.visionModel;
+  }
+  /**
+   * Gets the Ollama base URL (for diagnostics)
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Sets the vision model
+   */
+  setModel(model) {
+    this.visionModel = model;
+  }
+  /**
+   * Sets instrumentation callbacks
+   */
+  setInstrumentation(instrumentation) {
+    this.instrumentation = instrumentation;
+  }
+};
+var defaultAnalyzer = null;
+function getVisionAnalyzer(options) {
+  if (!defaultAnalyzer || options) {
+    defaultAnalyzer = new VisionAnalyzer(options);
+  }
+  return defaultAnalyzer;
+}
 export {
   OllamaClient,
   STYLEGUIDE_PATHS,
   UILINT_DEFAULT_OLLAMA_MODEL,
+  UILINT_DEFAULT_VISION_MODEL,
+  VisionAnalyzer,
   analyzeConsistency,
   buildAnalysisPrompt,
   buildConsistencyPrompt,
@@ -517,6 +2000,7 @@ export {
   generateStyleGuideFromStyles,
   getDefaultStyleGuidePath,
   getOllamaClient,
+  getVisionAnalyzer,
   hasAnalyzableGroups,
   hasStdin,
   isJSON,