@ingcreators/annot-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1355 @@
+import { loadImage as _, createCanvas as B } from "@napi-rs/canvas";
+import st from "pixelmatch";
+import { readFile as at, writeFile as x } from "node:fs/promises";
+import { isAbsolute as w } from "node:path";
+import { createAnnotator as ct } from "@ingcreators/annot-annotator";
+import { Server as lt } from "@modelcontextprotocol/sdk/server/index.js";
+import { ListToolsRequestSchema as ut, CallToolRequestSchema as dt } from "@modelcontextprotocol/sdk/types.js";
+import { StdioServerTransport as ft } from "@modelcontextprotocol/sdk/server/stdio.js";
+const ht = { width: 1280, height: 800, deviceScaleFactor: 1 }, pt = "load";
+async function H(t, e) {
+  const r = { ...ht, ...e.viewport }, o = e.waitFor ?? pt, n = e.fullPage ?? !1, s = await t.acquire();
+  let i, a = !1;
+  const c = () => {
+    a || (a = !0, t.release());
+  };
+  try {
+    i = await s.newContext({
+      viewport: { width: r.width, height: r.height },
+      deviceScaleFactor: r.deviceScaleFactor
+    });
+    const l = await i.newPage();
+    await l.goto(e.url, { waitUntil: o });
+    const u = await l.screenshot({ fullPage: n, type: "png" }), h = new Uint8Array(u.buffer, u.byteOffset, u.byteLength), T = i;
+    return { pngBytes: h, handle: {
+      page: l,
+      async close() {
+        if (!a)
+          try {
+            await T.close();
+          } finally {
+            c();
+          }
+      }
+    } };
+  } catch (l) {
+    if (i)
+      try {
+        await i.close();
+      } catch {
+      }
+    throw c(), l;
+  }
+}
+const mt = 3e4;
+class gt {
+  #i;
+  #s;
+  #t;
+  #o;
+  #e = 0;
+  #r;
+  constructor(e, r = {}) {
+    this.#i = e, this.#s = r.idleTimeoutMs ?? mt;
+  }
+  /**
+   * Acquire a browser instance. The pool launches lazily on the
+   * first call. Subsequent acquires return the same shared
+   * instance until every borrow has been released and the idle
+   * timeout has elapsed.
+   *
+   * The caller MUST call {@link release} (typically in a `finally`)
+   * after they're done so the pool can track outstanding borrows
+   * accurately.
+   */
+  async acquire() {
+    return this.#n(), this.#e += 1, this.#t ? this.#t : (this.#o || (this.#o = this.#i.launch().then((e) => (this.#t = e, this.#o = void 0, e)).catch((e) => {
+      throw this.#o = void 0, this.#e = Math.max(0, this.#e - 1), e;
+    })), this.#o);
+  }
+  /**
+   * Release a previously-acquired browser. Decrements the
+   * refcount; when it reaches zero an idle timer starts. A
+   * follow-up `acquire` within the idle window reuses the same
+   * instance; otherwise the timer fires and the browser closes.
+   */
+  release() {
+    this.#e !== 0 && (this.#e -= 1, this.#e === 0 && this.#t && this.#a());
+  }
+  /**
+   * Close the pooled browser immediately, regardless of refcount.
+   * Intended for explicit teardown (e.g. SIGINT / SIGTERM
+   * handlers); regular flows should rely on the idle timer.
+   */
+  async shutdown() {
+    this.#n();
+    const e = this.#t;
+    this.#t = void 0, this.#e = 0, e && await e.close();
+  }
+  /** Refcount of outstanding borrows. Exposed for tests / metrics. */
+  get activeBorrows() {
+    return this.#e;
+  }
+  /** Whether a browser is currently launched. Exposed for tests. */
+  get isLaunched() {
+    return this.#t !== void 0;
+  }
+  // ─── internals ────────────────────────────────────────────────
+  #n() {
+    this.#r && (clearTimeout(this.#r), this.#r = void 0);
+  }
+  #a() {
+    this.#n(), this.#r = setTimeout(() => {
+      const e = this.#t;
+      this.#t = void 0, this.#r = void 0, e?.close().catch(() => {
+      });
+    }, this.#s), this.#r.unref?.();
+  }
+}
+function yt(t = {}) {
+  return new gt(
+    {
+      async launch() {
+        let e;
+        try {
+          ({ chromium: e } = await import("playwright-core"));
+        } catch (r) {
+          throw new U(
+            "Failed to load `playwright-core`. Reinstall `@ingcreators/annot-mcp` to restore the dependency.",
+            r
+          );
+        }
+        try {
+          return await e.launch({ headless: !0 });
+        } catch (r) {
+          throw new U(
+            "Failed to launch Chromium. Run `npx playwright install chromium` to download the runtime, then retry.",
+            r
+          );
+        }
+      }
+    },
+    t
+  );
+}
+class U extends Error {
+  cause;
+  constructor(e, r) {
+    super(e), this.name = "ChromiumUnavailableError", this.cause = r;
+  }
+}
+class F extends Error {
+  locator;
+  constructor(e, r) {
+    super(r), this.name = "LocatorResolutionError", this.locator = e;
+  }
+}
+async function f(t, e) {
+  const r = await t.locator(e).boundingBox();
+  if (!r)
+    throw new F(
+      e,
+      `Locator "${e}" resolved to no visible element. Check the selector matches at least one element and the element is inside the captured viewport.`
+    );
+  return r;
+}
+async function wt(t, e) {
+  switch (e.type) {
+    case "rect": {
+      const r = e.bbox ?? await f(t, p(e.locator));
+      return { ...m(e), type: "rect", bbox: r };
+    }
+    case "circle": {
+      if (e.center !== void 0 && e.radius !== void 0)
+        return {
+          ...m(e),
+          type: "circle",
+          center: e.center,
+          radius: e.radius
+        };
+      const r = await f(t, p(e.locator));
+      return {
+        ...m(e),
+        type: "circle",
+        center: S(r),
+        radius: Math.min(r.width, r.height) / 2
+      };
+    }
+    case "arrow": {
+      const r = e.from ?? S(await f(t, p(e.fromLocator))), o = e.to ?? S(await f(t, p(e.toLocator)));
+      return {
+        ...m(e),
+        type: "arrow",
+        from: r,
+        to: o
+      };
+    }
+    case "text": {
+      const r = e.at ?? vt(
+        await f(t, p(e.locator)),
+        e.fontSize
+      ), o = {
+        ...m(e),
+        type: "text",
+        at: r,
+        content: e.content
+      };
+      return e.fontSize !== void 0 && (o.fontSize = e.fontSize), e.anchor !== void 0 && (o.anchor = e.anchor), o;
+    }
+    case "callout": {
+      const r = e.at ?? await $t(t, e.atLocator), o = e.targetBbox ?? await f(t, p(e.targetLocator));
+      return {
+        ...m(e),
+        type: "callout",
+        at: r,
+        targetBbox: o,
+        content: e.content
+      };
+    }
+    case "raw":
+      return e;
+  }
+}
+async function bt(t, e) {
+  const r = [];
+  for (const o of e)
+    r.push(await wt(t, o));
+  return r;
+}
+async function $t(t, e) {
+  if (!e)
+    throw new F(
+      "<callout.at>",
+      "callout annotations require either `at` or `atLocator`."
+    );
+  const r = await f(t, e);
+  return S(r);
+}
+function S(t) {
+  return { x: t.x + t.width / 2, y: t.y + t.height / 2 };
+}
+function vt(t, e) {
+  const r = (e ?? 14) + 2;
+  return { x: t.x, y: Math.max(0, t.y - r) };
+}
+function p(t) {
+  if (t === void 0)
+    throw new F(
+      "<missing>",
+      "Internal error: annotation passed schema validation without a locator or bbox. This is a bug."
+    );
+  return t;
+}
+function m(t) {
+  if (t.type === "raw")
+    return {};
+  const e = {};
+  return t.intent !== void 0 && (e.intent = t.intent), t.stroke !== void 0 && (e.stroke = t.stroke), t.strokeWidth !== void 0 && (e.strokeWidth = t.strokeWidth), t.fill !== void 0 && (e.fill = t.fill), t.color !== void 0 && (e.color = t.color), e;
+}
+const xt = 4;
+function Et(t, e, r) {
+  const o = new Uint8Array(e * r), n = [];
+  for (let s = 0; s < r; s++)
+    for (let i = 0; i < e; i++) {
+      const a = s * e + i;
+      if (o[a] || !X(t, a)) continue;
+      const c = Pt(t, o, i, s, e, r);
+      c.count >= xt && n.push({
+        x: c.minX,
+        y: c.minY,
+        width: c.maxX - c.minX + 1,
+        height: c.maxY - c.minY + 1
+      });
+    }
+  return n;
+}
+function X(t, e) {
+  return t[e * 4 + 3] > 0;
+}
+function Pt(t, e, r, o, n, s) {
+  const i = {
+    count: 0,
+    minX: r,
+    minY: o,
+    maxX: r,
+    maxY: o
+  }, a = [r, o];
+  for (; a.length > 0; ) {
+    const c = a.pop(), l = a.pop();
+    if (l < 0 || l >= n || c < 0 || c >= s) continue;
+    const u = c * n + l;
+    e[u] || X(t, u) && (e[u] = 1, i.count += 1, l < i.minX && (i.minX = l), c < i.minY && (i.minY = c), l > i.maxX && (i.maxX = l), c > i.maxY && (i.maxY = c), a.push(l + 1, c), a.push(l - 1, c), a.push(l, c + 1), a.push(l, c - 1));
+  }
+  return i;
+}
+class Lt extends Error {
+  constructor(e, r) {
+    super(
+      `Cannot compare screenshots of different dimensions: before is ${e.width}×${e.height}, after is ${r.width}×${r.height}.`
+    ), this.name = "DimensionMismatchError";
+  }
+}
+async function Ot(t, e, r = {}) {
+  const [o, n] = await Promise.all([
+    _(Buffer.from(t)),
+    _(Buffer.from(e))
+  ]);
+  if (o.width !== n.width || o.height !== n.height)
+    throw new Lt(
+      { width: o.width, height: o.height },
+      { width: n.width, height: n.height }
+    );
+  const { width: s, height: i } = o, a = N(o, s, i), c = N(n, s, i), l = new Uint8Array(s * i * 4), u = st(a, c, l, s, i, {
+    threshold: r.threshold ?? 0.1,
+    includeAA: !1,
+    diffMask: !0
+  }), h = Et(l, s, i);
+  return { mismatchedPixels: u, regions: h, width: s, height: i };
+}
+function N(t, e, r) {
+  const n = B(e, r).getContext("2d");
+  n.drawImage(t, 0, 0);
+  const s = n.getImageData(0, 0, e, r).data;
+  return new Uint8Array(s.buffer, s.byteOffset, s.byteLength);
+}
+const R = {
+  BBox: {
+    type: "object",
+    required: ["x", "y", "width", "height"],
+    additionalProperties: !1,
+    properties: {
+      x: { type: "number" },
+      y: { type: "number" },
+      width: { type: "number", minimum: 0 },
+      height: { type: "number", minimum: 0 }
+    }
+  },
+  Point: {
+    type: "object",
+    required: ["x", "y"],
+    additionalProperties: !1,
+    properties: {
+      x: { type: "number" },
+      y: { type: "number" }
+    }
+  },
+  Intent: {
+    type: "string",
+    enum: ["info", "warning", "error", "success", "neutral"]
+  },
+  AnnotationStyle: {
+    type: "object",
+    additionalProperties: !1,
+    properties: {
+      intent: { $ref: "#/$defs/Intent" },
+      stroke: { type: "string" },
+      strokeWidth: { type: "number", minimum: 0 },
+      fill: { type: "string" },
+      color: { type: "string" }
+    }
+  },
+  Locator: { type: "string", minLength: 1 }
+}, St = {
+  type: "object",
+  required: ["type", "bbox"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "rect" },
+    bbox: { $ref: "#/$defs/BBox" },
+    intent: { $ref: "#/$defs/Intent" },
+    stroke: { type: "string" },
+    strokeWidth: { type: "number", minimum: 0 },
+    fill: { type: "string" },
+    color: { type: "string" }
+  }
+}, At = {
+  type: "object",
+  required: ["type", "center", "radius"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "circle" },
+    center: { $ref: "#/$defs/Point" },
+    radius: { type: "number", minimum: 0 },
+    intent: { $ref: "#/$defs/Intent" },
+    stroke: { type: "string" },
+    strokeWidth: { type: "number", minimum: 0 },
+    fill: { type: "string" },
+    color: { type: "string" }
+  }
+}, Rt = {
+  type: "object",
+  required: ["type", "from", "to"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "arrow" },
+    from: { $ref: "#/$defs/Point" },
+    to: { $ref: "#/$defs/Point" },
+    intent: { $ref: "#/$defs/Intent" },
+    stroke: { type: "string" },
+    strokeWidth: { type: "number", minimum: 0 },
+    color: { type: "string" }
+  }
+}, Tt = {
+  type: "object",
+  required: ["type", "at", "content"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "text" },
+    at: { $ref: "#/$defs/Point" },
+    content: { type: "string" },
+    fontSize: { type: "number", minimum: 0 },
+    anchor: { type: "string", enum: ["start", "middle", "end"] },
+    intent: { $ref: "#/$defs/Intent" },
+    color: { type: "string" }
+  }
+}, kt = {
+  type: "object",
+  required: ["type", "at", "targetBbox", "content"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "callout" },
+    at: { $ref: "#/$defs/Point" },
+    targetBbox: { $ref: "#/$defs/BBox" },
+    content: { type: "string" },
+    intent: { $ref: "#/$defs/Intent" },
+    stroke: { type: "string" },
+    color: { type: "string" }
+  }
+}, z = {
+  type: "object",
+  required: ["type", "svgFragment"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "raw" },
+    svgFragment: { type: "string" }
+  }
+}, It = {
+  oneOf: [St, At, Rt, Tt, kt, z]
+}, _t = {
+  type: "object",
+  required: ["type"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "rect" },
+    bbox: { $ref: "#/$defs/BBox" },
+    locator: { $ref: "#/$defs/Locator" },
+    intent: { $ref: "#/$defs/Intent" },
+    stroke: { type: "string" },
+    strokeWidth: { type: "number", minimum: 0 },
+    fill: { type: "string" },
+    color: { type: "string" }
+  },
+  anyOf: [{ required: ["bbox"] }, { required: ["locator"] }]
+}, Bt = {
+  type: "object",
+  required: ["type"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "circle" },
+    center: { $ref: "#/$defs/Point" },
+    radius: { type: "number", minimum: 0 },
+    locator: { $ref: "#/$defs/Locator" },
+    intent: { $ref: "#/$defs/Intent" },
+    stroke: { type: "string" },
+    strokeWidth: { type: "number", minimum: 0 },
+    fill: { type: "string" },
+    color: { type: "string" }
+  },
+  anyOf: [{ required: ["center", "radius"] }, { required: ["locator"] }]
+}, Ft = {
+  type: "object",
+  required: ["type"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "arrow" },
+    from: { $ref: "#/$defs/Point" },
+    fromLocator: { $ref: "#/$defs/Locator" },
+    to: { $ref: "#/$defs/Point" },
+    toLocator: { $ref: "#/$defs/Locator" },
+    intent: { $ref: "#/$defs/Intent" },
+    stroke: { type: "string" },
+    strokeWidth: { type: "number", minimum: 0 },
+    color: { type: "string" }
+  },
+  allOf: [
+    { anyOf: [{ required: ["from"] }, { required: ["fromLocator"] }] },
+    { anyOf: [{ required: ["to"] }, { required: ["toLocator"] }] }
+  ]
+}, Ct = {
+  type: "object",
+  required: ["type", "content"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "text" },
+    at: { $ref: "#/$defs/Point" },
+    locator: { $ref: "#/$defs/Locator" },
+    content: { type: "string" },
+    fontSize: { type: "number", minimum: 0 },
+    anchor: { type: "string", enum: ["start", "middle", "end"] },
+    intent: { $ref: "#/$defs/Intent" },
+    color: { type: "string" }
+  },
+  anyOf: [{ required: ["at"] }, { required: ["locator"] }]
+}, Ut = {
+  type: "object",
+  required: ["type", "content"],
+  additionalProperties: !1,
+  properties: {
+    type: { const: "callout" },
+    at: { $ref: "#/$defs/Point" },
+    atLocator: { $ref: "#/$defs/Locator" },
+    targetBbox: { $ref: "#/$defs/BBox" },
+    targetLocator: { $ref: "#/$defs/Locator" },
+    content: { type: "string" },
+    intent: { $ref: "#/$defs/Intent" },
+    stroke: { type: "string" },
+    color: { type: "string" }
+  },
+  allOf: [
+    { anyOf: [{ required: ["at"] }, { required: ["atLocator"] }] },
+    { anyOf: [{ required: ["targetBbox"] }, { required: ["targetLocator"] }] }
+  ]
+}, Nt = {
+  oneOf: [_t, Bt, Ft, Ct, Ut, z]
+}, qt = {
+  type: "object",
+  required: ["bbox"],
+  additionalProperties: !1,
+  properties: {
+    bbox: { $ref: "#/$defs/BBox" },
+    style: { type: "string", enum: ["solid", "mosaic", "blur"] },
+    color: { type: "string" }
+  }
+}, Wt = {
+  type: "object",
+  additionalProperties: !1,
+  properties: {
+    bbox: { $ref: "#/$defs/BBox" },
+    locator: { $ref: "#/$defs/Locator" },
+    style: { type: "string", enum: ["solid", "mosaic", "blur"] },
+    color: { type: "string" }
+  },
+  anyOf: [{ required: ["bbox"] }, { required: ["locator"] }]
+};
+function Y(t, e = {}) {
+  const r = e.stroke ?? "red", o = e.strokeWidth ?? 2, n = e.fill ?? "none";
+  return `<rect x="${t.x}" y="${t.y}" width="${t.width}" height="${t.height}" fill="${v(n)}" stroke="${v(r)}" stroke-width="${o}"/>`;
+}
+function V(t, e, r = {}) {
+  const o = r.color ?? "red", n = r.strokeWidth ?? 2, s = `annot-mcp-arrow-${Dt()}`;
+  return `<defs><marker id="${s}" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto" markerUnits="strokeWidth"><path d="M 0 0 L 10 5 L 0 10 z" fill="${v(o)}"/></marker></defs><line x1="${t.x}" y1="${t.y}" x2="${e.x}" y2="${e.y}" stroke="${v(o)}" stroke-width="${n}" marker-end="url(#${s})"/>`;
+}
+function J(t, e, r = {}) {
+  const o = r.color ?? "red", n = r.fontSize ?? 14, s = r.anchor ?? "start";
+  return `<text x="${t.x}" y="${t.y}" fill="${v(o)}" font-size="${n}" text-anchor="${s}">` + Gt(e) + "</text>";
+}
+let k = 0;
+function Dt() {
+  return k = k + 1 | 0, k;
+}
+function v(t) {
+  return t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function Gt(t) {
+  return t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+const Mt = {
+  info: { stroke: "#3b82f6", fill: "rgba(59, 130, 246, 0.12)", text: "#1e40af" },
+  warning: { stroke: "#f59e0b", fill: "rgba(245, 158, 11, 0.12)", text: "#92400e" },
+  error: { stroke: "#ef4444", fill: "rgba(239, 68, 68, 0.12)", text: "#991b1b" },
+  success: { stroke: "#10b981", fill: "rgba(16, 185, 129, 0.12)", text: "#065f46" },
+  neutral: { stroke: "#6b7280", fill: "rgba(107, 114, 128, 0.12)", text: "#374151" }
+}, jt = "error";
+function E(t) {
+  const e = t.intent ?? jt, r = Mt[e];
+  return {
+    stroke: t.stroke ?? r.stroke,
+    fill: t.fill ?? "none",
+    text: t.color ?? r.text
+  };
+}
+function C(t) {
+  return t.map(Ht).join("");
+}
+function Ht(t) {
+  switch (t.type) {
+    case "rect":
+      return Xt(t);
+    case "circle":
+      return zt(t);
+    case "arrow":
+      return Yt(t);
+    case "text":
+      return Vt(t);
+    case "callout":
+      return Jt(t);
+    case "raw":
+      return Kt(t);
+  }
+}
+function Xt(t) {
+  const e = E(t);
+  return Y(t.bbox, {
+    stroke: e.stroke,
+    strokeWidth: t.strokeWidth ?? 2,
+    fill: e.fill
+  });
+}
+function zt(t) {
+  const e = E(t), r = t.strokeWidth ?? 2;
+  return `<circle cx="${t.center.x}" cy="${t.center.y}" r="${t.radius}" fill="${W(e.fill)}" stroke="${W(e.stroke)}" stroke-width="${r}"/>`;
+}
+function Yt(t) {
+  const e = E(t);
+  return V(t.from, t.to, {
+    color: e.stroke,
+    strokeWidth: t.strokeWidth ?? 2
+  });
+}
+function Vt(t) {
+  const e = E(t);
+  return J(t.at, t.content, {
+    color: e.text,
+    fontSize: t.fontSize ?? 14,
+    anchor: t.anchor ?? "start"
+  });
+}
+function Jt(t) {
+  const e = E(t), r = t.targetBbox, o = Zt(r, t.at);
+  return Y(r, {
+    stroke: e.stroke,
+    strokeWidth: t.strokeWidth ?? 2,
+    fill: e.fill
+  }) + V(t.at, o, {
+    color: e.stroke,
+    strokeWidth: 2
+  }) + J(t.at, t.content, {
+    color: e.text,
+    fontSize: 14,
+    anchor: "start"
+  });
+}
+function Kt(t) {
+  return t.svgFragment;
+}
+function Zt(t, e) {
+  const r = q(e.x, t.x, t.x + t.width), o = q(e.y, t.y, t.y + t.height);
+  return { x: r, y: o };
+}
+function q(t, e, r) {
+  return Math.min(Math.max(t, e), r);
+}
+function W(t) {
+  return t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+const D = [137, 80, 78, 71, 13, 10, 26, 10], P = 12, Qt = "IHDR", te = 16, ee = 20, G = 24;
+class $ extends Error {
+  constructor(e) {
+    super(e), this.name = "InvalidPngError";
+  }
+}
+function K(t) {
+  if (t.byteLength < G)
+    throw new $(
+      `Expected at least ${G} bytes for a PNG header, got ${t.byteLength}.`
+    );
+  for (let s = 0; s < D.length; s++)
+    if (t[s] !== D[s])
+      throw new $(
+        "Input does not start with the PNG signature (89 50 4E 47 0D 0A 1A 0A). Confirm the input is a PNG — JPEG / WebP / other formats are not supported in v1."
+      );
+  const e = new DataView(t.buffer, t.byteOffset, t.byteLength), r = String.fromCharCode(
+    t[P],
+    t[P + 1],
+    t[P + 2],
+    t[P + 3]
+  );
+  if (r !== Qt)
+    throw new $(
+      `Expected IHDR chunk after PNG signature, found "${r}". The file may be a corrupt or non-standard PNG.`
+    );
+  const o = e.getUint32(te, !1), n = e.getUint32(ee, !1);
+  if (o === 0 || n === 0)
+    throw new $(`PNG dimensions ${o}×${n} include a zero axis.`);
+  return { width: o, height: n };
+}
+class y extends Error {
+  constructor(e) {
+    super(e), this.name = "InvalidImageInputError";
+  }
+}
+const re = "data:", oe = /^data:image\/png;base64,/i;
+async function A(t) {
+  if (typeof t != "string" || t.length === 0)
+    throw new y(
+      "`image` must be a non-empty string (data URL or absolute filesystem path)."
+    );
+  if (t.startsWith(re))
+    return ne(t);
+  if (!w(t))
+    throw new y(
+      `Filesystem path "${t}" is not absolute. Pass an absolute path so resolution doesn't depend on the MCP server's working directory.`
+    );
+  return ie(t);
+}
+function ne(t) {
+  if (!oe.test(t))
+    throw new y(
+      "Only `data:image/png;base64,...` URLs are supported. JPEG / WebP / SVG data URLs are not accepted in v1."
+    );
+  const e = t.slice(t.indexOf(",") + 1), r = se(e), o = Z(r);
+  return { bytes: r, dataUrl: t, dimensions: o };
+}
+async function ie(t) {
+  let e;
+  try {
+    const n = await at(t);
+    e = new Uint8Array(n.buffer, n.byteOffset, n.byteLength);
+  } catch (n) {
+    const s = n instanceof Error ? n.message : String(n);
+    throw new y(`Failed to read image at "${t}": ${s}`);
+  }
+  const r = Z(e), o = `data:image/png;base64,${ae(e)}`;
+  return { bytes: e, dataUrl: o, dimensions: r };
+}
+function Z(t) {
+  try {
+    return K(t);
+  } catch (e) {
+    throw e instanceof $ ? new y(e.message) : e;
+  }
+}
+function se(t) {
+  const e = Buffer.from(t, "base64");
+  return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+}
+function ae(t) {
+  return Buffer.from(t.buffer, t.byteOffset, t.byteLength).toString("base64");
+}
+const ce = "solid", le = "#000000", M = 16, ue = 12;
+async function Q(t, e) {
+  if (e.length === 0)
+    return t;
+  const r = await _(Buffer.from(t)), o = B(r.width, r.height), n = o.getContext("2d");
+  n.drawImage(r, 0, 0);
+  for (const i of e) {
+    if (i.bbox.width <= 0 || i.bbox.height <= 0) continue;
+    switch (i.style ?? ce) {
+      case "solid":
+        de(n, i.bbox, i.color ?? le);
+        break;
+      case "mosaic":
+        fe(n, r, i.bbox);
+        break;
+      case "blur":
+        he(n, r, i.bbox);
+        break;
+    }
+  }
+  const s = o.toBuffer("image/png");
+  return new Uint8Array(s.buffer, s.byteOffset, s.byteLength);
+}
+function de(t, e, r) {
+  t.save(), t.fillStyle = r, t.fillRect(e.x, e.y, e.width, e.height), t.restore();
+}
+function fe(t, e, r) {
+  const o = Math.max(1, Math.round(r.width / M)), n = Math.max(1, Math.round(r.height / M)), s = B(o, n), i = s.getContext("2d");
+  i.imageSmoothingEnabled = !1, i.drawImage(e, r.x, r.y, r.width, r.height, 0, 0, o, n), t.save(), t.imageSmoothingEnabled = !1, t.drawImage(s, 0, 0, o, n, r.x, r.y, r.width, r.height), t.restore();
+}
+function he(t, e, r) {
+  t.save(), t.beginPath(), t.rect(r.x, r.y, r.width, r.height), t.clip(), t.filter = `blur(${ue}px)`, t.drawImage(e, 0, 0), t.restore();
+}
+const tt = "annot_annotate_screenshot", pe = {
+  name: tt,
+  description: "Overlay annotations (rectangles, circles, arrows, callouts, text) on a PNG screenshot. Annotation positions are specified as bounding boxes or points; pair with `annot_annotate_url` if you want locator-driven positioning. Returns the annotated PNG inline unless `output` is specified, in which case the PNG is written to that absolute path.",
+  inputSchema: {
+    type: "object",
+    required: ["image", "annotations"],
+    additionalProperties: !1,
+    properties: {
+      image: {
+        type: "string",
+        description: "Source image. Either a `data:image/png;base64,...` URL or an absolute filesystem path to a PNG file."
+      },
+      annotations: {
+        type: "array",
+        items: { $ref: "#/$defs/BboxAnnotation" },
+        description: "Ordered list of annotations to overlay. Each annotation declares its shape, position, and (optionally) an `intent` shorthand for the colour theme (`info` | `warning` | `error` | `success` | `neutral`)."
+      },
+      output: {
+        type: "string",
+        description: "Optional absolute filesystem path. When set, the annotated PNG is written here and the tool returns a text confirmation; otherwise the PNG bytes are returned inline."
+      }
+    },
+    $defs: {
+      ...R,
+      BboxAnnotation: It
+    }
+  }
+};
+async function me(t, e) {
+  try {
+    const r = ge(t), o = await A(r.image), n = C(r.annotations), s = e.annotator.toPng({
+      originalDataUrl: o.dataUrl,
+      annotationsSvg: n,
+      width: o.dimensions.width,
+      height: o.dimensions.height
+    });
+    return r.output ? (await x(r.output, s), {
+      content: [
+        {
+          type: "text",
+          text: `Wrote ${s.byteLength}-byte annotated PNG to ${r.output} (${o.dimensions.width}×${o.dimensions.height}, ${r.annotations.length} annotation${r.annotations.length === 1 ? "" : "s"}).`
+        }
+      ]
+    }) : {
+      content: [
+        {
+          type: "image",
+          data: we(s),
+          mimeType: "image/png"
+        }
+      ]
+    };
+  } catch (r) {
+    return ye(r);
+  }
+}
+function ge(t) {
+  if (typeof t.image != "string")
+    throw new y("`image` is required and must be a string.");
+  if (!Array.isArray(t.annotations))
+    throw new I("`annotations` is required and must be an array.");
+  const e = t.annotations;
+  let r;
+  if (t.output !== void 0) {
+    if (typeof t.output != "string")
+      throw new I("`output` must be a string when provided.");
+    if (!w(t.output))
+      throw new I(
+        `\`output\` path "${t.output}" must be absolute so the file lands at a predictable location.`
+      );
+    r = t.output;
+  }
+  return { image: t.image, annotations: e, output: r };
+}
+class I extends Error {
+  constructor(e) {
+    super(e), this.name = "InvalidToolInputError";
+  }
+}
+function ye(t) {
+  return {
+    content: [{ type: "text", text: t instanceof Error ? `${t.name}: ${t.message}` : `Unknown error: ${String(t)}` }],
+    isError: !0
+  };
+}
+function we(t) {
+  return Buffer.from(t.buffer, t.byteOffset, t.byteLength).toString("base64");
+}
+const et = "annot_annotate_url", be = {
+  name: et,
+  description: 'Open a URL in a headless browser, capture a screenshot, and overlay annotations whose positions are specified as Playwright locator strings (`button:has-text("Submit")`, `[data-testid="email"]`, `role=button[name="Sign in"]`) or bounding boxes. Returns the annotated PNG inline unless `output` is specified.',
+  inputSchema: {
+    type: "object",
+    required: ["url", "annotations"],
+    additionalProperties: !1,
+    properties: {
+      url: {
+        type: "string",
+        format: "uri",
+        description: "Page URL to capture."
+      },
+      annotations: {
+        type: "array",
+        items: { $ref: "#/$defs/LocatorAnnotation" },
+        description: "Ordered list of annotations to overlay. Each annotation declares its shape and position via `bbox` / `from` / `to` / `at` (coordinate path) or `locator` / `fromLocator` / `toLocator` / `atLocator` (Playwright locator string)."
+      },
+      viewport: {
+        type: "object",
+        additionalProperties: !1,
+        properties: {
+          width: { type: "integer", minimum: 1, default: 1280 },
+          height: { type: "integer", minimum: 1, default: 800 },
+          deviceScaleFactor: { type: "number", minimum: 0.1, default: 1 }
+        },
+        description: "Viewport size. Default 1280×800 at 1× device pixel ratio."
+      },
+      fullPage: {
+        type: "boolean",
+        default: !1,
+        description: "Capture the full scrollable page rather than just the visible viewport. Locator resolution still depends on the actual DOM layout — off-viewport locators only resolve when `fullPage` is true."
+      },
+      waitFor: {
+        type: "string",
+        enum: ["load", "domcontentloaded", "networkidle"],
+        default: "load"
+      },
+      output: {
+        type: "string",
+        description: "Optional absolute filesystem path. When set, the annotated PNG is written here and the tool returns a text confirmation."
+      }
+    },
+    $defs: {
+      ...R,
+      LocatorAnnotation: Nt
+    }
+  }
+};
+class b extends Error {
+  constructor(e) {
+    super(e), this.name = "InvalidAnnotateUrlInputError";
+  }
+}
+async function $e(t, e) {
+  try {
+    const r = ve(t), o = await H(e.pool, {
+      url: r.url,
+      viewport: r.viewport,
+      fullPage: r.fullPage,
+      waitFor: r.waitFor
+    });
+    let n;
+    try {
+      n = await bt(
+        o.handle.page,
+        r.annotations
+      );
+    } finally {
+      await o.handle.close();
+    }
+    const s = K(o.pngBytes), i = C(n), a = e.annotator.toPng({
+      originalDataUrl: `data:image/png;base64,${j(o.pngBytes)}`,
+      annotationsSvg: i,
+      width: s.width,
+      height: s.height
+    });
+    return r.output ? (await x(r.output, a), {
+      content: [
+        {
+          type: "text",
+          text: `Wrote ${a.byteLength}-byte annotated PNG to ${r.output} (${s.width}×${s.height}, ${r.annotations.length} annotation${r.annotations.length === 1 ? "" : "s"}, captured from ${r.url}).`
+        }
+      ]
+    }) : {
+      content: [
+        {
+          type: "image",
+          data: j(a),
+          mimeType: "image/png"
+        }
+      ]
+    };
+  } catch (r) {
+    return xe(r);
+  }
+}
+function ve(t) {
+  if (typeof t.url != "string" || t.url.length === 0)
+    throw new b("`url` is required and must be a non-empty string.");
+  if (!Array.isArray(t.annotations))
+    throw new b("`annotations` is required and must be an array.");
+  const e = t.annotations;
+  let r;
+  if (t.viewport !== void 0) {
+    if (typeof t.viewport != "object" || t.viewport === null)
+      throw new b("`viewport` must be an object when provided.");
+    const i = t.viewport, a = typeof i.width == "number" ? i.width : 1280, c = typeof i.height == "number" ? i.height : 800, l = typeof i.deviceScaleFactor == "number" ? i.deviceScaleFactor : 1;
+    r = { width: a, height: c, deviceScaleFactor: l };
+  }
+  const o = t.fullPage === !0, n = t.waitFor === "domcontentloaded" || t.waitFor === "networkidle" ? t.waitFor : "load";
+  let s;
+  if (t.output !== void 0) {
+    if (typeof t.output != "string")
+      throw new b("`output` must be a string when provided.");
+    if (!w(t.output))
+      throw new b(`\`output\` path "${t.output}" must be absolute.`);
+    s = t.output;
+  }
+  return {
+    url: t.url,
+    annotations: e,
+    viewport: r,
+    fullPage: o,
+    waitFor: n,
+    output: s
+  };
+}
+function xe(t) {
+  return {
+    content: [{ type: "text", text: t instanceof Error ? `${t.name}: ${t.message}` : `Unknown error: ${String(t)}` }],
+    isError: !0
+  };
+}
+function j(t) {
+  return Buffer.from(t.buffer, t.byteOffset, t.byteLength).toString("base64");
+}
+const rt = "annot_compare_screenshots", Ee = {
+  name: rt,
+  description: "Compare two screenshots (must have identical dimensions) and return a PNG of the `after` image with changed regions highlighted as red rectangles. Useful for visual-diff PR review.",
+  inputSchema: {
+    type: "object",
+    required: ["before", "after"],
+    additionalProperties: !1,
+    properties: {
+      before: {
+        type: "string",
+        description: "`data:image/png;base64,...` URL or absolute filesystem path."
+      },
+      after: {
+        type: "string",
+        description: "`data:image/png;base64,...` URL or absolute filesystem path."
+      },
+      threshold: {
+        type: "number",
+        minimum: 0,
+        maximum: 1,
+        default: 0.1,
+        description: "Pixelmatch sensitivity (0 = strict, 1 = permissive)."
+      },
+      includeChangeList: {
+        type: "boolean",
+        default: !1,
+        description: "When true, append a text content block listing the changed-region bboxes alongside the annotated PNG."
+      },
+      output: { type: "string" }
+    }
+  }
+};
+class L extends Error {
+  constructor(e) {
+    super(e), this.name = "InvalidCompareInputError";
+  }
+}
+async function Pe(t, e) {
+  try {
+    if (typeof t.before != "string")
+      throw new L("`before` is required and must be a string.");
+    if (typeof t.after != "string")
+      throw new L("`after` is required and must be a string.");
+    const r = typeof t.threshold == "number" ? t.threshold : 0.1, o = t.includeChangeList === !0;
+    let n;
+    if (t.output !== void 0) {
+      if (typeof t.output != "string")
+        throw new L("`output` must be a string when provided.");
+      if (!w(t.output))
+        throw new L(`\`output\` path "${t.output}" must be absolute.`);
+      n = t.output;
+    }
+    const [s, i] = await Promise.all([
+      A(t.before),
+      A(t.after)
+    ]), a = await Ot(s.bytes, i.bytes, { threshold: r }), c = a.regions.map((d) => ({
+      type: "rect",
+      bbox: d,
+      intent: "warning"
+    })), l = C(c), u = e.annotator.toPng({
+      originalDataUrl: i.dataUrl,
+      annotationsSvg: l,
+      width: a.width,
+      height: a.height
+    });
+    if (n)
+      return await x(n, u), { content: [{ type: "text", text: `Wrote ${u.byteLength}-byte diff-annotated PNG to ${n} (${a.width}×${a.height}, ${a.regions.length} changed region${a.regions.length === 1 ? "" : "s"}, ${a.mismatchedPixels} mismatched pixel${a.mismatchedPixels === 1 ? "" : "s"}).` }] };
+    const h = {
+      type: "image",
+      data: Buffer.from(u.buffer, u.byteOffset, u.byteLength).toString(
+        "base64"
+      ),
+      mimeType: "image/png"
+    };
+    if (!o)
+      return { content: [h] };
+    const T = `${a.regions.length} changed region${a.regions.length === 1 ? "" : "s"}, ${a.mismatchedPixels} mismatched pixel${a.mismatchedPixels === 1 ? "" : "s"}:
+` + a.regions.map((d, it) => `  [${it + 1}] x=${d.x} y=${d.y} w=${d.width} h=${d.height}`).join(`
+`);
+    return {
+      content: [h, { type: "text", text: T }]
+    };
+  } catch (r) {
+    return {
+      content: [{ type: "text", text: r instanceof Error ? `${r.name}: ${r.message}` : `Unknown error: ${String(r)}` }],
+      isError: !0
+    };
+  }
+}
+const ot = "annot_redact_screenshot", Le = {
+  name: ot,
+  description: "Destructively burn redactions (solid / mosaic / blur) into a PNG screenshot. The original pixels under each region are irrecoverably replaced. Returns the redacted PNG inline unless `output` is specified.",
+  inputSchema: {
+    type: "object",
+    required: ["image", "regions"],
+    additionalProperties: !1,
+    properties: {
+      image: {
+        type: "string",
+        description: "`data:image/png;base64,...` URL or absolute filesystem path."
+      },
+      regions: {
+        type: "array",
+        items: { $ref: "#/$defs/BboxRedactRegion" }
+      },
+      output: { type: "string" }
+    },
+    $defs: {
+      ...R,
+      BboxRedactRegion: qt
+    }
+  }
+};
+class O extends Error {
+  constructor(e) {
+    super(e), this.name = "InvalidRedactInputError";
+  }
+}
+async function Oe(t) {
+  try {
+    if (typeof t.image != "string")
+      throw new O("`image` is required and must be a string.");
+    if (!Array.isArray(t.regions))
+      throw new O("`regions` is required and must be an array.");
+    const e = t.regions;
+    let r;
+    if (t.output !== void 0) {
+      if (typeof t.output != "string")
+        throw new O("`output` must be a string when provided.");
+      if (!w(t.output))
+        throw new O(`\`output\` path "${t.output}" must be absolute.`);
+      r = t.output;
+    }
+    const o = await A(t.image), n = await Q(o.bytes, e);
+    return r ? (await x(r, n), {
+      content: [
+        {
+          type: "text",
+          text: `Wrote ${n.byteLength}-byte redacted PNG to ${r} (${o.dimensions.width}×${o.dimensions.height}, ${e.length} region${e.length === 1 ? "" : "s"}).`
+        }
+      ]
+    }) : {
+      content: [
+        {
+          type: "image",
+          data: Buffer.from(
+            n.buffer,
+            n.byteOffset,
+            n.byteLength
+          ).toString("base64"),
+          mimeType: "image/png"
+        }
+      ]
+    };
+  } catch (e) {
+    return {
+      content: [{ type: "text", text: e instanceof Error ? `${e.name}: ${e.message}` : `Unknown error: ${String(e)}` }],
+      isError: !0
+    };
+  }
+}
+const nt = "annot_redact_url", Se = {
+  name: nt,
+  description: "Open a URL in a headless browser, capture a screenshot, and destructively burn redactions over regions identified by locator strings or bboxes. Returns the redacted PNG inline unless `output` is specified.",
+  inputSchema: {
+    type: "object",
+    required: ["url", "regions"],
+    additionalProperties: !1,
+    properties: {
+      url: { type: "string", format: "uri" },
+      regions: {
+        type: "array",
+        items: { $ref: "#/$defs/LocatorRedactRegion" }
+      },
+      viewport: {
+        type: "object",
+        additionalProperties: !1,
+        properties: {
+          width: { type: "integer", minimum: 1, default: 1280 },
+          height: { type: "integer", minimum: 1, default: 800 },
+          deviceScaleFactor: { type: "number", minimum: 0.1, default: 1 }
+        }
+      },
+      fullPage: { type: "boolean", default: !1 },
+      waitFor: {
+        type: "string",
+        enum: ["load", "domcontentloaded", "networkidle"],
+        default: "load"
+      },
+      output: { type: "string" }
+    },
+    $defs: {
+      ...R,
+      LocatorRedactRegion: Wt
+    }
+  }
+};
+class g extends Error {
+  constructor(e) {
+    super(e), this.name = "InvalidRedactUrlInputError";
+  }
+}
+async function Ae(t, e) {
+  try {
+    const r = Re(t), o = await H(e.pool, {
+      url: r.url,
+      viewport: r.viewport,
+      fullPage: r.fullPage,
+      waitFor: r.waitFor
+    });
+    let n;
+    try {
+      n = [];
+      for (const i of r.regions) {
+        const c = { bbox: await Te(o.handle.page, i) };
+        i.style !== void 0 && (c.style = i.style), i.color !== void 0 && (c.color = i.color), n.push(c);
+      }
+    } finally {
+      await o.handle.close();
+    }
+    const s = await Q(o.pngBytes, n);
+    return r.output ? (await x(r.output, s), {
+      content: [
+        {
+          type: "text",
+          text: `Wrote ${s.byteLength}-byte redacted PNG to ${r.output} (${r.regions.length} region${r.regions.length === 1 ? "" : "s"}, captured from ${r.url}).`
+        }
+      ]
+    }) : {
+      content: [
+        {
+          type: "image",
+          data: Buffer.from(
+            s.buffer,
+            s.byteOffset,
+            s.byteLength
+          ).toString("base64"),
+          mimeType: "image/png"
+        }
+      ]
+    };
+  } catch (r) {
+    return {
+      content: [{ type: "text", text: r instanceof Error ? `${r.name}: ${r.message}` : `Unknown error: ${String(r)}` }],
+      isError: !0
+    };
+  }
+}
+function Re(t) {
+  if (typeof t.url != "string" || t.url.length === 0)
+    throw new g("`url` is required and must be a non-empty string.");
+  if (!Array.isArray(t.regions))
+    throw new g("`regions` is required and must be an array.");
+  const e = t.regions;
+  let r;
+  if (t.viewport !== void 0) {
+    if (typeof t.viewport != "object" || t.viewport === null)
+      throw new g("`viewport` must be an object when provided.");
+    const i = t.viewport, a = typeof i.width == "number" ? i.width : 1280, c = typeof i.height == "number" ? i.height : 800, l = typeof i.deviceScaleFactor == "number" ? i.deviceScaleFactor : 1;
+    r = { width: a, height: c, deviceScaleFactor: l };
+  }
+  const o = t.fullPage === !0, n = t.waitFor === "domcontentloaded" || t.waitFor === "networkidle" ? t.waitFor : "load";
+  let s;
+  if (t.output !== void 0) {
+    if (typeof t.output != "string")
+      throw new g("`output` must be a string when provided.");
+    if (!w(t.output))
+      throw new g(`\`output\` path "${t.output}" must be absolute.`);
+    s = t.output;
+  }
+  return { url: t.url, regions: e, viewport: r, fullPage: o, waitFor: n, output: s };
+}
+async function Te(t, e) {
+  if (e.bbox !== void 0) return e.bbox;
+  if (e.locator !== void 0) return f(t, e.locator);
+  throw new g("redact region requires either `bbox` or `locator`.");
+}
+const ke = "annot-mcp", Ie = "0.1.0", _e = [
+  pe,
+  be,
+  Le,
+  Se,
+  Ee
+];
+function Be(t = {}) {
+  const e = new lt(
+    {
+      name: ke,
+      version: t.version ?? Ie
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  ), r = t.annotator ?? ct(t.annotatorOptions ?? {}), o = t.pool ?? yt();
+  return e.setRequestHandler(ut, async () => ({ tools: _e })), e.setRequestHandler(dt, async (n) => {
+    const { name: s, arguments: i } = n.params;
+    let a;
+    switch (s) {
+      case tt:
+        a = await me(i ?? {}, { annotator: r });
+        break;
+      case et:
+        a = await $e(i ?? {}, { annotator: r, pool: o });
+        break;
+      case ot:
+        a = await Oe(i ?? {});
+        break;
+      case nt:
+        a = await Ae(i ?? {}, { pool: o });
+        break;
+      case rt:
+        a = await Pe(i ?? {}, { annotator: r });
+        break;
+      default:
+        a = {
+          content: [{ type: "text", text: `Unknown tool: ${s}` }],
+          isError: !0
+        };
+    }
+    return a;
+  }), e;
+}
+async function Me() {
+  const t = Be(), e = new ft();
+  await t.connect(e);
+}
+export {
+  tt as ANNOTATE_SCREENSHOT_TOOL_NAME,
+  et as ANNOTATE_URL_TOOL_NAME,
+  It as BBOX_ANNOTATION_SCHEMA,
+  qt as BBOX_REDACT_REGION_SCHEMA,
+  gt as BrowserPool,
+  rt as COMPARE_SCREENSHOTS_TOOL_NAME,
+  U as ChromiumUnavailableError,
+  Lt as DimensionMismatchError,
+  y as InvalidImageInputError,
+  $ as InvalidPngError,
+  Nt as LOCATOR_ANNOTATION_SCHEMA,
+  Wt as LOCATOR_REDACT_REGION_SCHEMA,
+  F as LocatorResolutionError,
+  ot as REDACT_SCREENSHOT_TOOL_NAME,
+  nt as REDACT_URL_TOOL_NAME,
+  R as SHARED_DEFS,
+  Et as aggregateDiffRegions,
+  pe as annotateScreenshotTool,
+  be as annotateUrlTool,
+  C as bboxAnnotationsToSvg,
+  Q as burnRedactions,
+  H as capturePage,
+  Ee as compareScreenshotsTool,
+  yt as createChromiumPool,
+  Be as createServer,
+  Ot as diffScreenshots,
+  me as handleAnnotateScreenshot,
+  $e as handleAnnotateUrl,
+  Pe as handleCompareScreenshots,
+  Oe as handleRedactScreenshot,
+  Ae as handleRedactUrl,
+  K as readPngDimensions,
+  Le as redactScreenshotTool,
+  Se as redactUrlTool,
+  A as resolveImageInput,
+  f as resolveLocator,
+  wt as resolveLocatorAnnotation,
+  bt as resolveLocatorAnnotations,
+  Me as runStdioServer
+};