@oyerinde/caliper 0.1.3 → 0.2.0

package/dist/mcp.js

@@ -0,0 +1,2303 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { JSONRPCErrorResponseSchema as JSONRPCErrorResponseSchema$1, JSONRPCResultResponseSchema as JSONRPCResultResponseSchema$1, JSONRPCRequestSchema as JSONRPCRequestSchema$1, JSONRPCNotificationSchema as JSONRPCNotificationSchema$1 } from '@modelcontextprotocol/sdk/types.js';
+import { WebSocketServer } from 'ws';
+import { EventEmitter } from 'events';
+
+/**
+ * @name @oyerinde/caliper
+ * @author Daniel Oyerinde
+ * @license MIT
+ *
+ * Caliper - Browser Measurement Tool
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var PositionModeSchema = z.enum(["static", "relative", "absolute", "fixed", "sticky"]);
+var CursorContextSchema = z.enum(["parent", "child", "sibling"]);
+var RectSchema = z.object({
+  top: z.number(),
+  right: z.number(),
+  bottom: z.number(),
+  left: z.number(),
+  width: z.number(),
+  height: z.number(),
+  x: z.number(),
+  y: z.number()
+});
+var ScrollStateSchema = z.object({
+  initialScrollTop: z.number(),
+  initialScrollLeft: z.number(),
+  containerRect: RectSchema.nullable(),
+  absoluteDepth: z.number(),
+  hasStickyAncestor: z.boolean().optional()
+});
+var MeasurementLineSchema = z.object({
+  type: z.enum(["left", "top", "right", "bottom", "distance"]),
+  value: z.number(),
+  start: z.object({ x: z.number(), y: z.number() }),
+  end: z.object({ x: z.number(), y: z.number() }),
+  startSync: z.enum(["primary", "secondary"]).optional(),
+  endSync: z.enum(["primary", "secondary"]).optional()
+});
+var StickyConfigSchema = z.object({
+  top: z.number().nullable(),
+  bottom: z.number().nullable(),
+  left: z.number().nullable(),
+  right: z.number().nullable(),
+  naturalTop: z.number(),
+  naturalLeft: z.number(),
+  containerWidth: z.number(),
+  containerHeight: z.number(),
+  elementWidth: z.number(),
+  elementHeight: z.number(),
+  anchorAbsoluteDepth: z.number()
+});
+var MeasurementResultSchema = z.object({
+  context: CursorContextSchema.nullable(),
+  lines: z.array(MeasurementLineSchema),
+  primary: RectSchema,
+  secondary: RectSchema.nullable(),
+  timestamp: z.number(),
+  primaryHierarchy: z.array(ScrollStateSchema),
+  secondaryHierarchy: z.array(ScrollStateSchema),
+  primaryPosition: PositionModeSchema,
+  secondaryPosition: PositionModeSchema,
+  primaryWinX: z.number(),
+  primaryWinY: z.number(),
+  secondaryWinX: z.number(),
+  secondaryWinY: z.number(),
+  primarySticky: StickyConfigSchema.optional(),
+  secondarySticky: StickyConfigSchema.optional(),
+  primaryHasContainingBlock: z.boolean().optional(),
+  secondaryHasContainingBlock: z.boolean().optional()
+});
+var SelectionMetadataSchema = z.object({
+  rect: RectSchema.nullable(),
+  scrollHierarchy: z.array(ScrollStateSchema),
+  position: PositionModeSchema,
+  stickyConfig: StickyConfigSchema.optional(),
+  initialWindowX: z.number(),
+  initialWindowY: z.number(),
+  depth: z.number(),
+  hasContainingBlock: z.boolean().optional()
+});
+var ContextMetricsSchema = z.object({
+  rootFontSize: z.number(),
+  devicePixelRatio: z.number(),
+  viewportWidth: z.number(),
+  viewportHeight: z.number(),
+  visualViewportWidth: z.number().optional(),
+  visualViewportHeight: z.number().optional(),
+  scrollX: z.number(),
+  scrollY: z.number(),
+  documentWidth: z.number(),
+  documentHeight: z.number(),
+  orientation: z.enum(["portrait", "landscape"]),
+  preferences: z.object({
+    colorScheme: z.enum(["light", "dark", "no-preference"]),
+    reducedMotion: z.boolean()
+  })
+});
+var CaliperSelectorInputSchema = z.object({
+  selector: z.string(),
+  // The CSS selector or data-caliper-agent-id
+  tag: z.string(),
+  // e.g., "section"
+  timestamp: z.number(),
+  // When the copy was made
+  id: z.string().optional(),
+  // HTML id attribute
+  text: z.string().optional(),
+  // Visible text snippet
+  classes: z.array(z.string()).optional(),
+  // CSS classes (filtered)
+  tabId: z.string().optional(),
+  // Tab ID for cross-tab identification
+  nthChild: z.number().optional(),
+  x: z.number().optional(),
+  y: z.number().optional(),
+  depth: z.number().optional(),
+  marker: z.string().optional(),
+  // data-caliper-marker value
+  // Geometry Context for re-discovery
+  scrollHierarchy: z.array(ScrollStateSchema).optional(),
+  position: PositionModeSchema.optional(),
+  stickyConfig: StickyConfigSchema.optional(),
+  initialWindowX: z.number().optional(),
+  initialWindowY: z.number().optional(),
+  hasContainingBlock: z.boolean().optional(),
+  rect: RectSchema.optional()
+});
+var BoxEdgesSchema = z.object({
+  top: z.number(),
+  right: z.number(),
+  bottom: z.number(),
+  left: z.number()
+});
+var CaliperComputedStylesSchema = z.object({
+  // Box Model
+  display: z.string().optional(),
+  visibility: z.string().optional(),
+  position: z.string().optional(),
+  boxSizing: z.string().optional(),
+  // Spacing
+  padding: BoxEdgesSchema.optional(),
+  margin: BoxEdgesSchema.optional(),
+  border: BoxEdgesSchema.optional(),
+  // Flexbox/Grid
+  gap: z.number().nullable().optional(),
+  flexDirection: z.string().optional(),
+  justifyContent: z.string().optional(),
+  alignItems: z.string().optional(),
+  // Typography
+  fontSize: z.number().optional(),
+  fontWeight: z.string().optional(),
+  fontFamily: z.string().optional(),
+  lineHeight: z.union([z.number(), z.string()]).nullable().optional(),
+  letterSpacing: z.union([z.number(), z.string()]).optional(),
+  color: z.string().optional(),
+  // Visual
+  backgroundColor: z.string().optional(),
+  borderColor: z.string().optional(),
+  borderRadius: z.string().optional(),
+  boxShadow: z.string().optional(),
+  opacity: z.union([z.number(), z.string()]).optional(),
+  outline: z.string().optional(),
+  outlineColor: z.string().optional(),
+  zIndex: z.union([z.number(), z.string()]).nullable().optional(),
+  // Overflow
+  overflow: z.string().optional(),
+  overflowX: z.string().optional(),
+  overflowY: z.string().optional(),
+  contentVisibility: z.string().optional()
+});
+var ParentGapSchema = z.object({
+  top: z.number(),
+  // Distance from parent's padding-top edge to node's margin-top
+  left: z.number(),
+  // Distance from parent's padding-left edge to node's margin-left
+  bottom: z.number(),
+  // Distance from node's margin-bottom to parent's padding-bottom
+  right: z.number()
+  // Distance from node's margin-right to parent's padding-right
+});
+var SiblingGapSchema = z.object({
+  distance: z.number(),
+  direction: z.enum(["above", "below", "left", "right"]).nullable()
+}).nullable();
+var CaliperMeasurementsSchema = z.object({
+  toParent: ParentGapSchema,
+  toPreviousSibling: SiblingGapSchema,
+  toNextSibling: SiblingGapSchema,
+  indexInParent: z.number(),
+  siblingCount: z.number()
+});
+var CaliperNodeSchema = z.lazy(
+  () => z.object({
+    // Identity
+    agentId: z.string(),
+    selector: z.string(),
+    tag: z.string(),
+    htmlId: z.string().optional(),
+    classes: z.array(z.string()),
+    textContent: z.string().optional(),
+    // Geometry (document-relative)
+    rect: RectSchema,
+    // Viewport-relative position
+    viewportRect: z.object({
+      top: z.number(),
+      left: z.number()
+    }),
+    // Computed Styles
+    styles: CaliperComputedStylesSchema,
+    // Measurements
+    measurements: CaliperMeasurementsSchema,
+    // Tree structure
+    depth: z.number(),
+    parentAgentId: z.string().optional(),
+    childCount: z.number(),
+    children: z.array(CaliperNodeSchema),
+    marker: z.string().optional(),
+    ariaHidden: z.boolean().optional()
+  })
+);
+var WalkOptionsSchema = z.object({
+  maxDepth: z.number().optional(),
+  maxNodes: z.number().optional(),
+  continueFrom: z.string().optional(),
+  minElementSize: z.number().optional(),
+  ignoreSelectors: z.array(z.string()).optional()
+});
+var JSONRPCRequestSchema = JSONRPCRequestSchema$1;
+var JSONRPCNotificationSchema = JSONRPCNotificationSchema$1;
+var JSONRPCResultResponseSchema = JSONRPCResultResponseSchema$1;
+var JSONRPCErrorResponseSchema = JSONRPCErrorResponseSchema$1;
+var ViewportSchema = z.object({
+  width: z.number(),
+  height: z.number(),
+  scrollX: z.number(),
+  scrollY: z.number()
+});
+z.object({
+  top: z.number(),
+  left: z.number(),
+  width: z.number(),
+  height: z.number(),
+  absoluteX: z.number(),
+  absoluteY: z.number(),
+  zIndex: z.number().optional(),
+  agentId: z.string().optional()
+});
+var CaliperElementSummarySchema = z.object({
+  tagName: z.string(),
+  id: z.string().optional(),
+  classList: z.array(z.string()),
+  agentId: z.string().optional(),
+  text: z.string().optional()
+});
+var CALIPER_METHODS = {
+  SELECT: "CALIPER_SELECT",
+  MEASURE: "CALIPER_MEASURE",
+  INSPECT: "CALIPER_INSPECT",
+  FREEZE: "CALIPER_FREEZE",
+  CLEAR: "CALIPER_CLEAR",
+  WALK_DOM: "CALIPER_WALK_DOM",
+  WALK_AND_MEASURE: "CALIPER_WALK_AND_MEASURE",
+  GET_CONTEXT: "CALIPER_GET_CONTEXT",
+  REGISTER_TAB: "caliper/registerTab",
+  TAB_UPDATE: "caliper/tabUpdate",
+  STATE_UPDATE: "caliper/stateUpdate"
+};
+var CaliperMethodSchema = z.enum([
+  CALIPER_METHODS.SELECT,
+  CALIPER_METHODS.MEASURE,
+  CALIPER_METHODS.INSPECT,
+  CALIPER_METHODS.FREEZE,
+  CALIPER_METHODS.CLEAR,
+  CALIPER_METHODS.WALK_DOM,
+  CALIPER_METHODS.WALK_AND_MEASURE,
+  CALIPER_METHODS.GET_CONTEXT,
+  CALIPER_METHODS.REGISTER_TAB,
+  CALIPER_METHODS.TAB_UPDATE,
+  CALIPER_METHODS.STATE_UPDATE
+]);
+var SourceHintsSchema = z.object({
+  stableAnchors: z.array(z.string()),
+  suggestedGrep: z.string().optional(),
+  textContent: z.string().optional(),
+  accessibleName: z.string().optional(),
+  unstableClasses: z.array(z.string()),
+  tagName: z.string()
+});
+var CaliperActionResultSchema = z.union([
+  z.object({ success: z.literal(true), method: z.literal(CALIPER_METHODS.SELECT), selector: z.string(), selection: SelectionMetadataSchema, timestamp: z.number() }),
+  z.object({ success: z.literal(true), method: z.literal(CALIPER_METHODS.MEASURE), selector: z.string(), measurement: MeasurementResultSchema, timestamp: z.number() }),
+  z.object({
+    success: z.literal(true),
+    method: z.literal(CALIPER_METHODS.INSPECT),
+    selector: z.string(),
+    distances: z.object({
+      top: z.number(),
+      right: z.number(),
+      bottom: z.number(),
+      left: z.number(),
+      horizontal: z.number(),
+      vertical: z.number()
+    }),
+    computedStyles: CaliperComputedStylesSchema,
+    selection: SelectionMetadataSchema,
+    immediateChildCount: z.number().optional(),
+    descendantCount: z.number().optional(),
+    descendantsTruncated: z.boolean().optional(),
+    sourceHints: SourceHintsSchema.optional(),
+    timestamp: z.number()
+  }),
+  z.object({ success: z.literal(true), method: z.literal(CALIPER_METHODS.FREEZE), timestamp: z.number() }),
+  z.object({ success: z.literal(true), method: z.literal(CALIPER_METHODS.CLEAR), timestamp: z.number() }),
+  z.object({
+    success: z.literal(true),
+    method: z.literal(CALIPER_METHODS.WALK_DOM),
+    selector: z.string(),
+    domContext: z.object({
+      element: CaliperElementSummarySchema,
+      parent: CaliperElementSummarySchema.nullable(),
+      children: z.array(CaliperElementSummarySchema)
+    }),
+    timestamp: z.number()
+  }),
+  z.object({
+    success: z.literal(true),
+    method: z.literal(CALIPER_METHODS.WALK_AND_MEASURE),
+    selector: z.string(),
+    walkResult: z.object({
+      root: CaliperNodeSchema.optional(),
+      nodeCount: z.number(),
+      maxDepthReached: z.number(),
+      walkDurationMs: z.number(),
+      hasMore: z.boolean().optional(),
+      batchInstructions: z.string().optional(),
+      continuationToken: z.string().optional()
+    }),
+    timestamp: z.number(),
+    binaryPayload: z.custom().optional()
+  }),
+  z.object({
+    success: z.literal(true),
+    method: z.literal(CALIPER_METHODS.GET_CONTEXT),
+    context: ContextMetricsSchema,
+    timestamp: z.number()
+  }),
+  z.object({
+    success: z.literal(false),
+    method: CaliperMethodSchema,
+    selector: z.string().optional(),
+    error: z.string(),
+    timestamp: z.number(),
+    binaryPayload: z.custom().optional()
+  })
+]);
+var CaliperAgentStateSchema = z.object({
+  viewport: ViewportSchema,
+  activeSelection: SelectionMetadataSchema.nullable(),
+  selectionFingerprint: CaliperSelectorInputSchema.nullable(),
+  lastMeasurement: MeasurementResultSchema.nullable(),
+  measurementFingerprint: z.object({
+    primary: CaliperSelectorInputSchema,
+    secondary: CaliperSelectorInputSchema
+  }).nullable(),
+  lastUpdated: z.number()
+});
+var IdSchema = z.union([z.string(), z.number()]);
+var RpcFactory = class {
+  static request(method, params, id) {
+    return JSONRPCRequestSchema.parse({ jsonrpc: "2.0", method, params, id });
+  }
+  static response(id, result) {
+    return JSONRPCResultResponseSchema.parse({ jsonrpc: "2.0", id, result });
+  }
+  static error(id, code, message, data) {
+    return JSONRPCErrorResponseSchema.parse({ jsonrpc: "2.0", id, error: { code, message, data } });
+  }
+  static notification(method, params) {
+    return JSONRPCNotificationSchema.parse({ jsonrpc: "2.0", method, params });
+  }
+};
+var isId = (value) => {
+  return typeof value === "string" || typeof value === "number";
+};
+var isCaliperActionResult = (value) => {
+  return CaliperActionResultSchema.safeParse(value).success;
+};
+var CaliperResponseSchema = z.union([
+  z.object({
+    jsonrpc: z.literal("2.0"),
+    id: IdSchema,
+    result: CaliperActionResultSchema
+  }),
+  JSONRPCErrorResponseSchema
+]);
+var CaliperNotificationSchema = z.union([
+  z.object({
+    jsonrpc: z.literal("2.0"),
+    method: z.literal(CALIPER_METHODS.REGISTER_TAB),
+    params: z.object({
+      tabId: z.string(),
+      url: z.string(),
+      title: z.string(),
+      isFocused: z.boolean()
+    })
+  }),
+  z.object({
+    jsonrpc: z.literal("2.0"),
+    method: z.literal(CALIPER_METHODS.TAB_UPDATE),
+    params: z.object({
+      isFocused: z.boolean()
+    })
+  }),
+  z.object({
+    jsonrpc: z.literal("2.0"),
+    method: z.literal(CALIPER_METHODS.STATE_UPDATE),
+    params: CaliperAgentStateSchema
+  })
+]);
+var BridgeMessageSchema = z.union([
+  CaliperResponseSchema,
+  CaliperNotificationSchema,
+  JSONRPCResultResponseSchema
+]);
+z.object({
+  selector: z.string()
+});
+z.object({
+  primarySelector: z.string(),
+  secondarySelector: z.string()
+});
+z.object({
+  selector: z.string()
+});
+z.object({
+  selector: z.string(),
+  depth: z.number().optional()
+});
+WalkOptionsSchema.extend({
+  selector: z.string()
+});
+z.object({});
+var stringSerializer = (defaultValue = "") => ({
+  collectStrings: (value, collect) => collect(value),
+  serialize: (value, context) => {
+    context.view.setUint16(context.offset, context.getStringId(value));
+    context.offset += 2;
+  },
+  deserialize: (context) => {
+    const result = context.stringList[context.view.getUint16(context.offset)] || defaultValue || void 0;
+    context.offset += 2;
+    return result;
+  }
+});
+var optionalStringSerializer = () => ({
+  collectStrings: (value, collect) => collect(value),
+  serialize: (value, context) => {
+    context.view.setUint16(context.offset, context.getStringId(value));
+    context.offset += 2;
+  },
+  deserialize: (context) => {
+    const result = context.stringList[context.view.getUint16(context.offset)] || void 0;
+    context.offset += 2;
+    return result;
+  }
+});
+var floatSerializer = () => ({
+  collectStrings: () => {
+  },
+  serialize: (value, context) => {
+    context.view.setFloat32(context.offset, value ?? 0);
+    context.offset += 4;
+  },
+  deserialize: (context) => {
+    const result = context.view.getFloat32(context.offset);
+    context.offset += 4;
+    return result;
+  }
+});
+var boxEdgesSerializer = () => ({
+  collectStrings: () => {
+  },
+  serialize: (edges, context) => {
+    context.view.setFloat32(context.offset, edges?.top ?? 0);
+    context.offset += 4;
+    context.view.setFloat32(context.offset, edges?.right ?? 0);
+    context.offset += 4;
+    context.view.setFloat32(context.offset, edges?.bottom ?? 0);
+    context.offset += 4;
+    context.view.setFloat32(context.offset, edges?.left ?? 0);
+    context.offset += 4;
+  },
+  deserialize: (context) => {
+    const edges = {
+      top: context.view.getFloat32(context.offset),
+      right: context.view.getFloat32(context.offset + 4),
+      bottom: context.view.getFloat32(context.offset + 8),
+      left: context.view.getFloat32(context.offset + 12)
+    };
+    context.offset += 16;
+    if (edges.top === 0 && edges.right === 0 && edges.bottom === 0 && edges.left === 0) {
+      return void 0;
+    }
+    return edges;
+  }
+});
+var nullableNumberSerializer = () => ({
+  collectStrings: (value, collect) => collect(value == null ? null : String(value)),
+  serialize: (value, context) => {
+    context.view.setUint16(context.offset, context.getStringId(value == null ? null : String(value)));
+    context.offset += 2;
+  },
+  deserialize: (context) => {
+    const strValue = context.stringList[context.view.getUint16(context.offset)] || null;
+    context.offset += 2;
+    return strValue === null ? null : parseFloat(strValue);
+  }
+});
+var numberOrStringSerializer = (defaultValue = "") => ({
+  collectStrings: (value, collect) => collect(value == null ? void 0 : String(value)),
+  serialize: (value, context) => {
+    context.view.setUint16(context.offset, context.getStringId(value == null ? void 0 : String(value)));
+    context.offset += 2;
+  },
+  deserialize: (context) => {
+    const id = context.view.getUint16(context.offset);
+    const strValue = context.stringList[id];
+    context.offset += 2;
+    if (!strValue && id === 0) return defaultValue;
+    if (!strValue) return void 0;
+    const numValue = parseFloat(strValue);
+    return isNaN(numValue) ? strValue : numValue;
+  }
+});
+var nullableNumberOrStringSerializer = () => ({
+  collectStrings: (value, collect) => collect(value == null ? null : String(value)),
+  serialize: (value, context) => {
+    context.view.setUint16(context.offset, context.getStringId(value == null ? null : String(value)));
+    context.offset += 2;
+  },
+  deserialize: (context) => {
+    const strValue = context.stringList[context.view.getUint16(context.offset)] || null;
+    context.offset += 2;
+    if (strValue === null) return null;
+    const numValue = parseFloat(strValue);
+    return isNaN(numValue) ? strValue : numValue;
+  }
+});
+var STYLE_SERIALIZERS = {
+  display: stringSerializer(),
+  visibility: stringSerializer(),
+  position: stringSerializer(),
+  boxSizing: stringSerializer(),
+  padding: boxEdgesSerializer(),
+  margin: boxEdgesSerializer(),
+  border: boxEdgesSerializer(),
+  gap: nullableNumberSerializer(),
+  flexDirection: optionalStringSerializer(),
+  justifyContent: optionalStringSerializer(),
+  alignItems: optionalStringSerializer(),
+  fontSize: floatSerializer(),
+  fontWeight: stringSerializer(),
+  fontFamily: stringSerializer(),
+  lineHeight: nullableNumberOrStringSerializer(),
+  letterSpacing: numberOrStringSerializer(0),
+  color: stringSerializer(),
+  backgroundColor: stringSerializer(),
+  borderColor: optionalStringSerializer(),
+  borderRadius: stringSerializer("0"),
+  boxShadow: optionalStringSerializer(),
+  opacity: numberOrStringSerializer(1),
+  outline: optionalStringSerializer(),
+  outlineColor: optionalStringSerializer(),
+  zIndex: nullableNumberOrStringSerializer(),
+  overflow: stringSerializer("visible"),
+  overflowX: stringSerializer("visible"),
+  overflowY: stringSerializer("visible"),
+  contentVisibility: stringSerializer("visible")
+};
+var STYLE_KEYS = Object.keys(STYLE_SERIALIZERS);
+var BitBridge = class _BitBridge {
+  static MAGIC = 1128352841;
+  // "CALI"
+  static serialize(root) {
+    const strings = /* @__PURE__ */ new Map();
+    const stringList = [];
+    const getStringId = (str) => {
+      if (str === void 0 || str === null) return 0;
+      let id = strings.get(str);
+      if (id === void 0) {
+        id = stringList.length + 1;
+        strings.set(str, id);
+        stringList.push(str);
+      }
+      return id;
+    };
+    const stack = [root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      getStringId(node.tag);
+      getStringId(node.selector);
+      getStringId(node.agentId);
+      getStringId(node.htmlId);
+      getStringId(node.textContent);
+      getStringId(node.marker);
+      node.classes?.forEach((className) => getStringId(className));
+      for (const key of STYLE_KEYS) {
+        const serializer = STYLE_SERIALIZERS[key];
+        serializer.collectStrings(
+          node.styles[key],
+          getStringId
+        );
+      }
+      if (node.children) {
+        for (let i = node.children.length - 1; i >= 0; i--) {
+          stack.push(node.children[i]);
+        }
+      }
+    }
+    const encoder = new TextEncoder();
+    const encodedStrings = stringList.map((rawString) => encoder.encode(rawString));
+    let dictSize = 8;
+    encodedStrings.forEach((bytes) => dictSize += 2 + bytes.length);
+    const buffer = new ArrayBuffer(dictSize + 1024 * 1024 * 5);
+    const view = new DataView(buffer);
+    let offset = 0;
+    view.setUint32(offset, _BitBridge.MAGIC);
+    offset += 4;
+    view.setUint32(offset, stringList.length);
+    offset += 4;
+    encodedStrings.forEach((bytes) => {
+      view.setUint16(offset, bytes.length);
+      offset += 2;
+      new Uint8Array(buffer, offset, bytes.length).set(bytes);
+      offset += bytes.length;
+    });
+    const nodeStack = [root];
+    while (nodeStack.length > 0) {
+      const node = nodeStack.pop();
+      view.setUint16(offset, getStringId(node.tag));
+      offset += 2;
+      view.setUint16(offset, getStringId(node.selector));
+      offset += 2;
+      view.setUint16(offset, getStringId(node.agentId));
+      offset += 2;
+      view.setUint16(offset, getStringId(node.htmlId));
+      offset += 2;
+      view.setUint16(offset, getStringId(node.textContent));
+      offset += 2;
+      view.setUint16(offset, getStringId(node.marker));
+      offset += 2;
+      view.setUint8(offset, node.ariaHidden ? 1 : 0);
+      offset += 1;
+      const classes = node.classes || [];
+      view.setUint16(offset, classes.length);
+      offset += 2;
+      classes.forEach((className) => {
+        view.setUint16(offset, getStringId(className));
+        offset += 2;
+      });
+      view.setFloat32(offset, node.rect.top);
+      offset += 4;
+      view.setFloat32(offset, node.rect.left);
+      offset += 4;
+      view.setFloat32(offset, node.rect.width);
+      offset += 4;
+      view.setFloat32(offset, node.rect.height);
+      offset += 4;
+      view.setFloat32(offset, node.rect.bottom);
+      offset += 4;
+      view.setFloat32(offset, node.rect.right);
+      offset += 4;
+      view.setFloat32(offset, node.viewportRect.top);
+      offset += 4;
+      view.setFloat32(offset, node.viewportRect.left);
+      offset += 4;
+      const ctx = { view, offset, getStringId };
+      for (const key of STYLE_KEYS) {
+        const serializer = STYLE_SERIALIZERS[key];
+        serializer.serialize(
+          node.styles[key],
+          ctx
+        );
+      }
+      offset = ctx.offset;
+      view.setUint16(offset, node.depth);
+      offset += 2;
+      const children = node.children || [];
+      view.setUint16(offset, children.length);
+      offset += 2;
+      for (let i = children.length - 1; i >= 0; i--) {
+        nodeStack.push(children[i]);
+      }
+    }
+    return new Uint8Array(buffer, 0, offset);
+  }
+  static deserialize(data) {
+    const buffer = data.buffer;
+    const view = new DataView(buffer, data.byteOffset, data.byteLength);
+    let offset = 0;
+    const magic = view.getUint32(offset);
+    offset += 4;
+    if (magic !== _BitBridge.MAGIC) throw new Error("Invalid BitBridge format");
+    const stringCount = view.getUint32(offset);
+    offset += 4;
+    const stringList = [""];
+    const decoder = new TextDecoder();
+    for (let i = 0; i < stringCount; i++) {
+      const len = view.getUint16(offset);
+      offset += 2;
+      const str = decoder.decode(new Uint8Array(buffer, data.byteOffset + offset, len));
+      stringList.push(str);
+      offset += len;
+    }
+    const root = this.deserializeNode(view, offset, stringList);
+    offset = root.newOffset;
+    const nodeStack = [{
+      node: root.node,
+      childrenToRead: root.childCount
+    }];
+    while (nodeStack.length > 0) {
+      const current = nodeStack[nodeStack.length - 1];
+      if (current.childrenToRead > 0) {
+        const childResult = this.deserializeNode(view, offset, stringList);
+        offset = childResult.newOffset;
+        childResult.node.parentAgentId = current.node.agentId;
+        current.node.children.push(childResult.node);
+        current.childrenToRead--;
+        if (childResult.childCount > 0) {
+          nodeStack.push({
+            node: childResult.node,
+            childrenToRead: childResult.childCount
+          });
+        }
+      } else {
+        nodeStack.pop();
+      }
+    }
+    return root.node;
+  }
+  static deserializeNode(view, offset, stringList) {
+    const tag = stringList[view.getUint16(offset)] || "";
+    offset += 2;
+    const selector = stringList[view.getUint16(offset)] || "";
+    offset += 2;
+    const agentId = stringList[view.getUint16(offset)] || "";
+    offset += 2;
+    const htmlId = stringList[view.getUint16(offset)] || void 0;
+    offset += 2;
+    const textContent = stringList[view.getUint16(offset)] || void 0;
+    offset += 2;
+    const marker = stringList[view.getUint16(offset)] || void 0;
+    offset += 2;
+    const ariaHidden = view.getUint8(offset) === 1;
+    offset += 1;
+    const classCount = view.getUint16(offset);
+    offset += 2;
+    const classes = [];
+    for (let i = 0; i < classCount; i++) {
+      classes.push(stringList[view.getUint16(offset)] || "");
+      offset += 2;
+    }
+    const rect = {
+      top: view.getFloat32(offset),
+      left: view.getFloat32(offset + 4),
+      width: view.getFloat32(offset + 8),
+      height: view.getFloat32(offset + 12),
+      bottom: view.getFloat32(offset + 16),
+      right: view.getFloat32(offset + 20),
+      x: 0,
+      y: 0
+    };
+    rect.x = rect.left;
+    rect.y = rect.top;
+    offset += 24;
+    const vTop = view.getFloat32(offset);
+    offset += 4;
+    const vLeft = view.getFloat32(offset);
+    offset += 4;
+    const ctx = { view, offset, stringList };
+    const styles = {};
+    for (const key of STYLE_KEYS) {
+      const serializer = STYLE_SERIALIZERS[key];
+      styles[key] = serializer.deserialize(ctx);
+    }
+    offset = ctx.offset;
+    const depth = view.getUint16(offset);
+    offset += 2;
+    const childCount = view.getUint16(offset);
+    offset += 2;
+    const node = {
+      agentId,
+      selector,
+      tag,
+      htmlId,
+      classes,
+      textContent,
+      rect,
+      viewportRect: { top: vTop, left: vLeft },
+      depth,
+      childCount,
+      children: [],
+      styles,
+      marker,
+      ariaHidden,
+      measurements: {
+        toParent: { top: 0, left: 0, bottom: 0, right: 0 },
+        toPreviousSibling: null,
+        toNextSibling: null,
+        indexInParent: 0,
+        siblingCount: childCount
+      }
+    };
+    return { node, childCount, newOffset: offset };
+  }
+  static packEnvelope(json, payload) {
+    const jsonBytes = new TextEncoder().encode(json);
+    const combined = new Uint8Array(4 + jsonBytes.byteLength + payload.byteLength);
+    const view = new DataView(combined.buffer);
+    view.setUint32(0, jsonBytes.byteLength);
+    combined.set(jsonBytes, 4);
+    combined.set(payload, 4 + jsonBytes.byteLength);
+    return combined;
+  }
+  static unpackEnvelope(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const jsonLen = view.getUint32(0);
+    const jsonStr = new TextDecoder().decode(data.subarray(4, 4 + jsonLen));
+    const payload = data.subarray(4 + jsonLen);
+    return { json: jsonStr, payload };
+  }
+};
+var MAX_DESCENDANT_COUNT = 1e3;
+var RECOMMENDED_PAGINATION_THRESHOLD = 40;
+
+// ../mcp-server/src/utils/logger.ts
+var Logger = class {
+  enabled = true;
+  prefix;
+  constructor(prefix) {
+    this.prefix = `[Caliper:${prefix}]`;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  info(...args) {
+    if (this.enabled) console.error(this.prefix, ...args);
+  }
+  warn(...args) {
+    if (this.enabled) console.error(this.prefix, "WARN:", ...args);
+  }
+  error(...args) {
+    if (this.enabled) console.error(this.prefix, "ERROR:", ...args);
+  }
+  debug(...args) {
+    if (this.enabled) console.error(this.prefix, "DEBUG:", ...args);
+  }
+};
+var createLogger = (prefix) => new Logger(prefix);
+
+// ../mcp-server/src/services/tab-manager.ts
+var logger2 = createLogger("tab-manager");
+var TabManager = class {
+  tabs = /* @__PURE__ */ new Map();
+  activeTabId = null;
+  registerTab(tab) {
+    this.tabs.set(tab.id, {
+      ...tab,
+      lastActive: Date.now()
+    });
+    this.activeTabId = tab.id;
+    logger2.info(`Tab registered: ${tab.title} (${tab.id})`);
+  }
+  updateTab(id, isFocused) {
+    const tab = this.tabs.get(id);
+    if (tab) {
+      tab.lastActive = Date.now();
+      if (isFocused) {
+        this.activeTabId = id;
+      }
+    }
+  }
+  removeTab(id, ws) {
+    const tab = this.tabs.get(id);
+    if (tab && tab.ws === ws) {
+      this.tabs.delete(id);
+      if (this.activeTabId === id) {
+        this.activeTabId = Array.from(this.tabs.keys())[0] || null;
+      }
+      logger2.info(`Tab disconnected: ${id}`);
+    }
+  }
+  getActiveTab() {
+    if (!this.activeTabId) return null;
+    return this.tabs.get(this.activeTabId) || null;
+  }
+  getTabById(id) {
+    return this.tabs.get(id) || null;
+  }
+  getAllTabs() {
+    return Array.from(this.tabs.values());
+  }
+  switchTab(id) {
+    if (this.tabs.has(id)) {
+      this.activeTabId = id;
+      return true;
+    }
+    return false;
+  }
+  getTabCount() {
+    return this.tabs.size;
+  }
+  findTabByUrl(urlFragment) {
+    for (const tab of this.tabs.values()) {
+      if (tab.url.includes(urlFragment)) {
+        return tab;
+      }
+    }
+    return null;
+  }
+};
+var tabManager = new TabManager();
+
+// ../mcp-server/src/utils/id.ts
+function generateId(prefix = "") {
+  const randomPart = Math.random().toString(36).substring(2, 11);
+  return prefix ? `${prefix}-${randomPart}` : randomPart;
+}
+
+// ../mcp-server/src/utils/errors.ts
+var BridgeError = class _BridgeError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BridgeError";
+    Object.setPrototypeOf(this, _BridgeError.prototype);
+  }
+};
+var BridgeTimeoutError = class _BridgeTimeoutError extends BridgeError {
+  constructor(method, attempt, totalRetries) {
+    const message = attempt < totalRetries ? `Bridge request timed out for method: ${method}. Retrying... (Attempt ${attempt + 1}/${totalRetries + 1})` : `Bridge request timed out for method: ${method}. The bridge is connected, but the operation took too long.`;
+    super(message);
+    this.name = "BridgeTimeoutError";
+    Object.setPrototypeOf(this, _BridgeTimeoutError.prototype);
+  }
+};
+var BridgeValidationError = class _BridgeValidationError extends BridgeError {
+  constructor(message = "Data connection unauthorized or malformed.") {
+    super(message);
+    this.name = "BridgeValidationError";
+    Object.setPrototypeOf(this, _BridgeValidationError.prototype);
+  }
+};
+
+// ../mcp-server/src/shared/constants.ts
+var DEFAULT_BRIDGE_PORT = 9876;
+var BRIDGE_REQUEST_TIMEOUT_MS = 9e4;
+
+// ../mcp-server/src/shared/events.ts
+var BRIDGE_EVENTS = {
+  STATE: "state"
+};
+
+// ../mcp-server/src/services/bridge-service.ts
+var logger3 = createLogger("mcp-bridge");
+function getExponentialBackoff(attempt, baseDelay) {
+  return Math.pow(2, attempt) * baseDelay;
+}
+var BridgeService = class extends EventEmitter {
+  wss = null;
+  pendingCalls = /* @__PURE__ */ new Map();
+  startupError = null;
+  constructor() {
+    super();
+  }
+  async start(port2 = DEFAULT_BRIDGE_PORT, retries = 3) {
+    if (this.wss) return;
+    const attemptStart = (currentPort, remaining) => {
+      return new Promise((resolve, reject) => {
+        try {
+          const server2 = new WebSocketServer({ port: currentPort });
+          server2.on("listening", () => {
+            this.wss = server2;
+            this.init();
+            resolve();
+          });
+          server2.on("error", (error) => {
+            const err = error;
+            if (err.code === "EADDRINUSE" && remaining > 0) {
+              const attemptNum = retries - remaining + 1;
+              const delay = getExponentialBackoff(attemptNum - 1, 500);
+              logger3.warn(
+                `Port ${currentPort} is currently in use. Retrying in ${delay}ms... (Attempt ${attemptNum}/${retries})`
+              );
+              server2.close();
+              server2.removeAllListeners();
+              setTimeout(() => {
+                attemptStart(currentPort, remaining - 1).then(resolve).catch(reject);
+              }, delay);
+            } else {
+              const errorMessage = err.code === "EADDRINUSE" ? `Port ${currentPort} is already in use by another process. Please close the other instance of Caliper or use a different port.` : `WebSocket server error: ${String(error)}`;
+              logger3.error(errorMessage);
+              this.startupError = errorMessage;
+              server2.close();
+              reject(new Error(errorMessage));
+            }
+          });
+        } catch (error) {
+          reject(error);
+        }
+      });
+    };
+    try {
+      await attemptStart(port2, retries);
+    } catch (error) {
+      if (!this.startupError) {
+        this.startupError = `Failed to start WebSocket relay after multiple attempts: ${String(error)}`;
+      }
+    }
+  }
+  init() {
+    if (!this.wss) return;
+    this.wss.on("connection", (ws) => {
+      let tabId = null;
+      ws.on("message", (data) => {
+        try {
+          let rawMessage;
+          let binaryPayload;
+          if (Buffer.isBuffer(data)) {
+            if (data[0] === 123) {
+              rawMessage = JSON.parse(data.toString());
+            } else {
+              const { json, payload } = BitBridge.unpackEnvelope(new Uint8Array(data));
+              rawMessage = JSON.parse(json);
+              binaryPayload = payload;
+            }
+          } else {
+            rawMessage = JSON.parse(data.toString());
+          }
+          const result = BridgeMessageSchema.safeParse(rawMessage);
+          if (!result.success) {
+            logger3.error("Invalid WS message format:", z.treeifyError(result.error));
+            const msgObj = rawMessage;
+            if (msgObj?.id !== void 0 && isId(msgObj.id)) {
+              const resolve = this.pendingCalls.get(String(msgObj.id));
+              if (resolve) {
+                resolve({ error: new BridgeValidationError().message });
+                this.pendingCalls.delete(String(msgObj.id));
+              }
+            }
+            return;
+          }
+          const message = result.data;
+          if ("id" in message) {
+            if ("result" in message) {
+              const resolve = this.pendingCalls.get(String(message.id));
+              if (resolve) {
+                const finalResult = message.result;
+                if (isCaliperActionResult(finalResult)) {
+                  if (finalResult.success && finalResult.method === CALIPER_METHODS.WALK_AND_MEASURE && binaryPayload) {
+                    try {
+                      const root = BitBridge.deserialize(binaryPayload);
+                      if ("walkResult" in finalResult) {
+                        finalResult.walkResult.root = root;
+                      }
+                    } catch (error) {
+                      logger3.error("Bit-Bridge reconstruction failed:", error);
+                    }
+                  }
+                  resolve(finalResult);
+                } else if (finalResult && typeof finalResult === "object" && "error" in finalResult) {
+                  resolve(finalResult);
+                } else {
+                  resolve({ error: "Unexpected result format received from bridge" });
+                }
+                this.pendingCalls.delete(String(message.id));
+              }
+            } else if ("error" in message) {
+              if (message.id !== null) {
+                const resolve = this.pendingCalls.get(String(message.id));
+                if (resolve) {
+                  resolve({ error: message.error.message });
+                  this.pendingCalls.delete(String(message.id));
+                }
+              }
+            }
+          } else if ("method" in message) {
+            if (message.method === CALIPER_METHODS.REGISTER_TAB) {
+              const { tabId: newTabId, url, title, isFocused } = message.params;
+              tabId = newTabId;
+              tabManager.registerTab({
+                id: tabId,
+                ws,
+                url,
+                title,
+                isFocused
+              });
+            } else if (message.method === CALIPER_METHODS.TAB_UPDATE) {
+              const { isFocused } = message.params;
+              if (tabId) {
+                tabManager.updateTab(tabId, isFocused);
+              }
+            } else if (message.method === CALIPER_METHODS.STATE_UPDATE) {
+              const state = message.params;
+              this.emit(BRIDGE_EVENTS.STATE, state);
+            }
+          }
+        } catch (error) {
+          logger3.error("WS Message Processing Error:", error);
+        }
+      });
+      ws.on("close", () => {
+        if (tabId) {
+          tabManager.removeTab(tabId, ws);
+        }
+      });
+    });
+    logger3.info(`WebSocket Relay initialized on port ${this.wss.options.port}`);
+  }
+  async call(method, params, retries = 0) {
+    if (this.startupError) {
+      throw new Error(`Caliper Bridge Unavailable: ${this.startupError}`);
+    }
+    const tab = tabManager.getActiveTab();
+    if (!tab) {
+      throw new Error(
+        "No active browser tab connected to Caliper Bridge. Ensure the browser is open with Caliper enabled."
+      );
+    }
+    const callWithTimeout = async (attempt) => {
+      const callId = generateId("mcp-call");
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          this.pendingCalls.delete(callId);
+          reject(new BridgeTimeoutError(method, attempt, retries));
+        }, BRIDGE_REQUEST_TIMEOUT_MS);
+        this.pendingCalls.set(callId, (res) => {
+          clearTimeout(timeout);
+          if ("error" in res && !("success" in res)) {
+            if (res.error === new BridgeValidationError().message) {
+              reject(new BridgeValidationError());
+            } else {
+              reject(new Error(res.error));
+            }
+          } else {
+            resolve(res);
+          }
+        });
+        tab.ws.send(JSON.stringify(RpcFactory.request(method, params, callId)));
+      });
+    };
+    let lastError = null;
+    for (let i = 0; i <= retries; i++) {
+      try {
+        return await callWithTimeout(i);
+      } catch (err) {
+        lastError = err;
+        const isRetryable = lastError instanceof BridgeTimeoutError || lastError instanceof BridgeValidationError;
+        if (!isRetryable) {
+          throw lastError;
+        }
+        if (i < retries) {
+          const delay = getExponentialBackoff(i, 300);
+          logger3.warn(`${lastError.message}. Retrying in ${delay}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError || new Error(`Failed bridge call: ${method}`);
+  }
+  async stop() {
+    return new Promise((resolve) => {
+      if (!this.wss) {
+        resolve();
+        return;
+      }
+      this.wss.close(() => {
+        logger3.info("WebSocket relay stopped.");
+        resolve();
+      });
+    });
+  }
+};
+var bridgeService = new BridgeService();
+
+// ../mcp-server/src/utils/color-utils.ts
+var NAMED_COLORS = {
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgreen: "#006400",
+  darkgrey: "#a9a9a9",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkslategrey: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  gray: "#808080",
+  green: "#008000",
+  greenyellow: "#adff2f",
+  grey: "#808080",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightgrey: "#d3d3d3",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightslategrey: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  maroon: "#800000",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370db",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navy: "#000080",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  purple: "#800080",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  slategrey: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  yellow: "#ffff00",
+  yellowgreen: "#9acd32"
+};
+function parseColor(colorStr) {
+  const trimmed = colorStr.trim().toLowerCase();
+  if (trimmed.startsWith("color-mix(")) {
+    return parseColorMix(trimmed);
+  }
+  if (NAMED_COLORS[trimmed]) {
+    return parseHex(NAMED_COLORS[trimmed]);
+  }
+  if (trimmed.startsWith("#")) {
+    return parseHex(trimmed);
+  }
+  if (trimmed.startsWith("rgb")) {
+    return parseRgb(trimmed);
+  }
+  if (trimmed.startsWith("hsl")) return parseHsl(trimmed);
+  if (trimmed.startsWith("hwb")) return parseHwb(trimmed);
+  if (trimmed.startsWith("oklch")) return parseOklch(trimmed);
+  if (trimmed.startsWith("oklab")) return parseOklab(trimmed);
+  if (trimmed.startsWith("lch")) return parseLch(trimmed);
+  if (trimmed.startsWith("lab")) return parseLab(trimmed);
+  if (trimmed.startsWith("color(")) return parseGenericColor(trimmed);
+  return { l: 0, a: 0, b: 0, alpha: 0, raw: colorStr };
+}
+function parseNumericValue(val, scale = 1) {
+  if (!val || val === "none") return 0;
+  const trimmed = val.trim().toLowerCase();
+  if (trimmed.endsWith("%")) return parseFloat(trimmed) / 100 * scale;
+  if (trimmed.endsWith("deg")) return parseFloat(trimmed);
+  if (trimmed.endsWith("rad")) return parseFloat(trimmed) * 180 / Math.PI;
+  if (trimmed.endsWith("grad")) return parseFloat(trimmed) * 0.9;
+  if (trimmed.endsWith("turn")) return parseFloat(trimmed) * 360;
+  return parseFloat(trimmed);
+}
+function parseHex(hex) {
+  let r = 0, g = 0, b = 0, a = 1;
+  if (hex.length === 4) {
+    r = parseInt(hex[1] + hex[1], 16);
+    g = parseInt(hex[2] + hex[2], 16);
+    b = parseInt(hex[3] + hex[3], 16);
+  } else if (hex.length === 7) {
+    r = parseInt(hex.slice(1, 3), 16);
+    g = parseInt(hex.slice(3, 5), 16);
+    b = parseInt(hex.slice(5, 7), 16);
+  } else if (hex.length === 9) {
+    r = parseInt(hex.slice(1, 3), 16);
+    g = parseInt(hex.slice(3, 5), 16);
+    b = parseInt(hex.slice(5, 7), 16);
+    a = parseInt(hex.slice(7, 9), 16) / 255;
+  }
+  return rgbToNormalized(r, g, b, a, hex);
+}
+function parseRgb(rgb) {
+  const parts = rgb.match(/rgba?\(([^)]+)\)/i)?.[1]?.split(/[\s,#/]+/).filter(Boolean) || [];
+  if (parts.length < 3) return { l: 0, a: 0, b: 0, alpha: 1, raw: rgb };
+  const r = parseNumericValue(parts[0], 255);
+  const g = parseNumericValue(parts[1], 255);
+  const b = parseNumericValue(parts[2], 255);
+  const a = parts[3] ? parseNumericValue(parts[3], 1) : 1;
+  return rgbToNormalized(r, g, b, a, rgb);
+}
+function parseHsl(hsl) {
+  const parts = hsl.match(/hsla?\(([^)]+)\)/i)?.[1]?.split(/[\s,#/]+/).filter(Boolean) || [];
+  if (parts.length < 3) return { l: 0, a: 0, b: 0, alpha: 1, raw: hsl };
+  const h = parseNumericValue(parts[0], 360) / 360;
+  const s = parseNumericValue(parts[1], 1);
+  const l = parseNumericValue(parts[2], 1);
+  const a = parts[3] ? parseNumericValue(parts[3], 1) : 1;
+  let r, g, b;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hueToRgb(p, q, h + 1 / 3);
+    g = hueToRgb(p, q, h);
+    b = hueToRgb(p, q, h - 1 / 3);
+  }
+  return rgbToNormalized(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a, hsl);
+}
+function hueToRgb(pVal, qVal, normalizedHue) {
+  if (normalizedHue < 0) normalizedHue += 1;
+  if (normalizedHue > 1) normalizedHue -= 1;
+  if (normalizedHue < 1 / 6) return pVal + (qVal - pVal) * 6 * normalizedHue;
+  if (normalizedHue < 1 / 2) return qVal;
+  if (normalizedHue < 2 / 3) return pVal + (qVal - pVal) * (2 / 3 - normalizedHue) * 6;
+  return pVal;
+}
+function parseHwb(hwb) {
+  const parts = hwb.match(/hwb\(([^)]+)\)/i)?.[1]?.split(/[\s,#/]+/).filter(Boolean) || [];
+  if (parts.length < 3) return { l: 0, a: 0, b: 0, alpha: 1, raw: hwb };
+  const h = parseNumericValue(parts[0], 360) / 360;
+  let w = parseNumericValue(parts[1], 1);
+  let b = parseNumericValue(parts[2], 1);
+  const a = parts[3] ? parseNumericValue(parts[3], 1) : 1;
+  if (w + b > 1) {
+    const sum = w + b;
+    w /= sum;
+    b /= sum;
+  }
+  const r_base = hueToRgb(0, 1, h + 1 / 3);
+  const g_base = hueToRgb(0, 1, h);
+  const b_base = hueToRgb(0, 1, h - 1 / 3);
+  const factor = 1 - w - b;
+  const r = r_base * factor + w;
+  const g = g_base * factor + w;
+  const b_final = b_base * factor + w;
+  return rgbToNormalized(r * 255, g * 255, b_final * 255, a, hwb);
+}
+function parseLab(lab) {
+  const parts = lab.match(/lab\(([^)]+)\)/i)?.[1]?.split(/[\s,#/]+/).filter(Boolean) || [];
+  if (parts.length < 3) return { l: 0, a: 0, b: 0, alpha: 1, raw: lab };
+  const L = parseNumericValue(parts[0], 100);
+  const A = parseNumericValue(parts[1], 125);
+  const B = parseNumericValue(parts[2], 125);
+  const alpha = parts[3] ? parseNumericValue(parts[3], 1) : 1;
+  const y = (L + 16) / 116;
+  const x = A / 500 + y;
+  const z4 = y - B / 200;
+  const [X50, Y50, Z50] = [f_inv(x) * 0.96422, f_inv(y) * 1, f_inv(z4) * 0.82521];
+  const X65 = X50 * 0.9555766 + Y50 * -0.0230393 + Z50 * 0.0631636;
+  const Y65 = X50 * -0.0282895 + Y50 * 1.0099416 + Z50 * 0.0210077;
+  const Z65 = X50 * 0.0122982 + Y50 * -0.020483 + Z50 * 1.3299098;
+  return xyzToOklab(X65, Y65, Z65, alpha, lab);
+}
+function f_inv(t) {
+  return t > 6 / 29 ? t ** 3 : 3 * (6 / 29) ** 2 * (t - 4 / 29);
+}
+function parseLch(lch) {
+  const parts = lch.match(/lch\(([^)]+)\)/i)?.[1]?.split(/[\s,#/]+/).filter(Boolean) || [];
+  if (parts.length < 3) return { l: 0, a: 0, b: 0, alpha: 1, raw: lch };
+  const L = parseNumericValue(parts[0], 100);
+  const C = parseNumericValue(parts[1], 150);
+  const H = parseNumericValue(parts[2], 1);
+  const alpha = parts[3] ? parseNumericValue(parts[3], 1) : 1;
+  const hRad = H * Math.PI / 180;
+  const a = C * Math.cos(hRad);
+  const b = C * Math.sin(hRad);
+  return parseLab(`lab(${L} ${a} ${b} / ${alpha})`);
+}
+function parseOklab(oklab) {
+  const parts = oklab.match(/oklab\(([^)]+)\)/i)?.[1]?.split(/[\s,#/]+/).filter(Boolean) || [];
+  if (parts.length < 3) return { l: 0, a: 0, b: 0, alpha: 1, raw: oklab };
+  return {
+    l: parseNumericValue(parts[0], 1),
+    a: parseNumericValue(parts[1], 0.4),
+    b: parseNumericValue(parts[2], 0.4),
+    alpha: parts[3] ? parseNumericValue(parts[3], 1) : 1,
+    raw: oklab
+  };
+}
+function parseOklch(oklch) {
+  const parts = oklch.match(/oklch\(([^)]+)\)/i)?.[1]?.split(/[\s,#/]+/).filter(Boolean) || [];
+  if (parts.length < 3) return { l: 0, a: 0, b: 0, alpha: 1, raw: oklch };
+  const L = parseNumericValue(parts[0], 1);
+  const C = parseNumericValue(parts[1], 1);
+  const H = parseNumericValue(parts[2], 1);
+  const A = parts[3] ? parseNumericValue(parts[3], 1) : 1;
+  const hRad = H * Math.PI / 180;
+  const a = C * Math.cos(hRad);
+  const b = C * Math.sin(hRad);
+  return { l: L, a, b, alpha: A, raw: oklch };
+}
+function parseGenericColor(str) {
+  const match = str.match(/color\(([^ ]+) ([^)]+)\)/i);
+  if (!match) return { l: 0, a: 0, b: 0, alpha: 1, raw: str };
+  const space = match[1].toLowerCase();
+  const parts = match[2].split(/[\s/]+/).filter(Boolean);
+  const c1 = parseNumericValue(parts[0], 1);
+  const c2 = parseNumericValue(parts[1], 1);
+  const c3 = parseNumericValue(parts[2], 1);
+  const a = parts[3] ? parseNumericValue(parts[3], 1) : 1;
+  if (space === "display-p3") {
+    return p3ToNormalized(c1, c2, c3, a, str);
+  }
+  if (space === "srgb") {
+    return rgbToNormalized(c1 * 255, c2 * 255, c3 * 255, a, str);
+  }
+  return rgbToNormalized(c1 * 255, c2 * 255, c3 * 255, a, str);
+}
+function parseColorMix(str) {
+  const match = str.match(/color-mix\(in ([^,]+),\s*([^,]+),\s*([^)]+)\)/i);
+  if (!match) return { l: 0, a: 0, b: 0, alpha: 0, raw: str };
+  match[1].trim().toLowerCase();
+  const c1Str = match[2].trim();
+  const c2Str = match[3].trim();
+  const p1Match = c1Str.match(/(.+)\s+(\d+(\.\d+)?%)/);
+  const p2Match = c2Str.match(/(.+)\s+(\d+(\.\d+)?%)/);
+  const c1 = parseColor(p1Match ? p1Match[1] : c1Str);
+  const c2 = parseColor(p2Match ? p2Match[1] : c2Str);
+  let weight = 0.5;
+  if (p1Match) weight = parseFloat(p1Match[2]) / 100;
+  else if (p2Match) weight = 1 - parseFloat(p2Match[2]) / 100;
+  return {
+    l: c1.l * weight + c2.l * (1 - weight),
+    a: c1.a * weight + c2.a * (1 - weight),
+    b: c1.b * weight + c2.b * (1 - weight),
+    alpha: c1.alpha * weight + c2.alpha * (1 - weight),
+    raw: str
+  };
+}
+function xyzToOklab(x, y, z4, alpha, raw) {
+  if (alpha === 0) return { l: 0, a: 0, b: 0, alpha: 0, raw };
+  const lValue = 0.8189330101 * x + 0.3618667424 * y - 0.1288597137 * z4;
+  const mValue = 0.0329845436 * x + 0.9293118715 * y + 0.0361456387 * z4;
+  const sValue = 0.0482003018 * x + 0.2643662691 * y + 0.633851707 * z4;
+  const lCubeRoot = Math.cbrt(lValue);
+  const mCubeRoot = Math.cbrt(mValue);
+  const sCubeRoot = Math.cbrt(sValue);
+  return {
+    l: 0.2104542553 * lCubeRoot + 0.793617785 * mCubeRoot - 0.0040720403 * sCubeRoot,
+    a: 1.9779984951 * lCubeRoot - 2.428592205 * mCubeRoot + 0.4505937099 * sCubeRoot,
+    b: 0.0259040371 * lCubeRoot + 0.7827717662 * mCubeRoot - 0.808675766 * sCubeRoot,
+    alpha,
+    raw
+  };
+}
+function rgbToNormalized(red, green, blue, alpha, raw) {
+  const linearRed = pivotRgb(red / 255);
+  const linearGreen = pivotRgb(green / 255);
+  const linearBlue = pivotRgb(blue / 255);
+  const x = 0.4124564 * linearRed + 0.3575761 * linearGreen + 0.1804375 * linearBlue;
+  const y = 0.2126729 * linearRed + 0.7151522 * linearGreen + 0.072175 * linearBlue;
+  const z4 = 0.0193339 * linearRed + 0.119192 * linearGreen + 0.9503041 * linearBlue;
+  return xyzToOklab(x, y, z4, alpha, raw);
+}
+function p3ToNormalized(red, green, blue, alpha, raw) {
+  const lp3 = (val) => val > 0.04045 ? Math.pow((val + 0.055) / 1.055, 2.4) : val / 12.92;
+  const linearRed = lp3(red);
+  const linearGreen = lp3(green);
+  const linearBlue = lp3(blue);
+  const x = 0.4865709 * linearRed + 0.2656677 * linearGreen + 0.1982119 * linearBlue;
+  const y = 0.2289748 * linearRed + 0.6917385 * linearGreen + 0.0592867 * linearBlue;
+  const z4 = 0 * linearRed + 0.0451104 * linearGreen + 1.0439444 * linearBlue;
+  return xyzToOklab(x, y, z4, alpha, raw);
+}
+function pivotRgb(colorValue) {
+  return colorValue > 0.04045 ? Math.pow((colorValue + 0.055) / 1.055, 2.4) : colorValue / 12.92;
+}
+function calculateDeltaE(color1, color2) {
+  const deltaL = color1.l - color2.l;
+  const deltaA = color1.a - color2.a;
+  const deltaB = color1.b - color2.b;
+  const deltaAlpha = color1.alpha - color2.alpha;
+  return Math.sqrt(
+    deltaL * deltaL + deltaA * deltaA + deltaB * deltaB + deltaAlpha * deltaAlpha * 0.5
+  );
+}
+function unpivotRgb(c) {
+  return c > 31308e-7 ? 1.055 * Math.pow(c, 1 / 2.4) - 0.055 : 12.92 * c;
+}
+function oklabToSrgbComponents(color) {
+  const lmsPrimeL = color.l + 0.3963377774 * color.a + 0.2158037573 * color.b;
+  const lmsPrimeM = color.l - 0.1055613458 * color.a - 0.0638541728 * color.b;
+  const lmsPrimeS = color.l - 0.0894841775 * color.a - 1.291485548 * color.b;
+  const lmsL = lmsPrimeL * lmsPrimeL * lmsPrimeL;
+  const lmsM = lmsPrimeM * lmsPrimeM * lmsPrimeM;
+  const lmsS = lmsPrimeS * lmsPrimeS * lmsPrimeS;
+  const linearR = 4.0767416621 * lmsL - 3.3077115913 * lmsM + 0.2309699292 * lmsS;
+  const linearG = -1.2684380046 * lmsL + 2.6097574011 * lmsM - 0.3413193965 * lmsS;
+  const linearB = -0.0041960863 * lmsL - 0.7034186147 * lmsM + 1.707612701 * lmsS;
+  return {
+    red: Math.min(1, Math.max(0, unpivotRgb(linearR))),
+    green: Math.min(1, Math.max(0, unpivotRgb(linearG))),
+    blue: Math.min(1, Math.max(0, unpivotRgb(linearB)))
+  };
+}
+function getLuminance(color) {
+  const { red, green, blue } = oklabToSrgbComponents(color);
+  const rLin = red <= 0.04045 ? red / 12.92 : Math.pow((red + 0.055) / 1.055, 2.4);
+  const gLin = green <= 0.04045 ? green / 12.92 : Math.pow((green + 0.055) / 1.055, 2.4);
+  const bLin = blue <= 0.04045 ? blue / 12.92 : Math.pow((blue + 0.055) / 1.055, 2.4);
+  return 0.2126 * rLin + 0.7152 * gLin + 0.0722 * bLin;
+}
+function calculateContrastRatio(fg, bg) {
+  const l1 = getLuminance(fg);
+  const l2 = getLuminance(bg);
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+// ../mcp-server/src/services/mcp-server.ts
+var logger4 = createLogger("mcp-server");
+var CaliperMcpServer = class {
+  server;
+  port;
+  lastState = null;
+  constructor(port2 = DEFAULT_BRIDGE_PORT) {
+    this.port = port2;
+    this.server = new McpServer({
+      name: "caliper-mcp-server",
+      version: "0.2.0"
+    });
+    this.registerTools();
+    this.registerResources();
+    this.registerPrompts();
+  }
+  registerTools() {
+    this.server.registerTool(
+      "caliper_list_tabs",
+      {
+        description: "List all browser tabs currently connected to the Caliper Agent Bridge.",
+        inputSchema: z.object({})
+      },
+      async () => {
+        const tabs = tabManager.getAllTabs().map((tab) => ({
+          id: tab.id,
+          title: tab.title,
+          url: tab.url,
+          isActive: tab.id === tabManager.getActiveTab()?.id
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(tabs, null, 2) }] };
+      }
+    );
+    this.server.registerTool(
+      "caliper_switch_tab",
+      {
+        description: "Switch the active targeting to a specific browser tab.",
+        inputSchema: z.object({
+          tabId: z.string().describe("The ID of the tab to target")
+        })
+      },
+      async ({ tabId }) => {
+        if (tabManager.switchTab(tabId)) {
+          return {
+            content: [
+              { type: "text", text: `Switched to tab: ${tabManager.getActiveTab()?.title}` }
+            ]
+          };
+        }
+        return {
+          content: [{ type: "text", text: `Error: Tab ${tabId} not found` }],
+          isError: true
+        };
+      }
+    );
+    this.server.registerTool(
+      "caliper_inspect",
+      {
+        description: `Get full geometry and computed visibility for an element.
+
+Returns comprehensive element data including:
+- distances: Position relative to viewport edges
+- computedStyles: All CSS computed values
+- selection: Scroll hierarchy and sticky configuration
+- immediateChildCount: Direct children count
+- descendantCount: Total descendants (capped at ${MAX_DESCENDANT_COUNT})
+- descendantsTruncated: True if descendant count was capped
+- sourceHints: Metadata for code discovery. Includes:
+    * suggestedGrep: A reliable pattern for finding this element in the codebase.
+    * stableAnchors: Prioritized list of stable attributes (data-testid, id, etc.).
+    * textContent: Truncated direct text content.
+    * unstableClasses: Classes that look like generated/hashed strings (to be ignored).
+
+Use descendantCount to decide whether to paginate caliper_walk_and_measure.
+If descendantCount > ${RECOMMENDED_PAGINATION_THRESHOLD} or descendantsTruncated is true, use maxNodes parameter.`,
+        inputSchema: z.object({
+          selector: z.string().describe(
+            "Element identifier. PRIORITIZE JSON Fingerprint, Caliper Agent ID (caliper-***), or CSS selector for maximum stabilization."
+          )
+        })
+      },
+      async ({ selector }) => {
+        try {
+          const result = await bridgeService.call(CALIPER_METHODS.INSPECT, { selector });
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error inspecting element: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.registerTool(
+      "caliper_measure",
+      {
+        description: "Perform a high-precision measurement between two elements.",
+        inputSchema: z.object({
+          primarySelector: z.string().describe(
+            "Identifier for the primary element. PRIORITIZE JSON Fingerprint, Caliper Agent ID (caliper-***), or CSS selector."
+          ),
+          secondarySelector: z.string().describe(
+            "Identifier for the target element. PRIORITIZE JSON Fingerprint, Caliper Agent ID (caliper-***), or CSS selector."
+          )
+        })
+      },
+      async ({ primarySelector, secondarySelector }) => {
+        try {
+          const result = await bridgeService.call(CALIPER_METHODS.MEASURE, {
+            primarySelector,
+            secondarySelector
+          });
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error performing measurement: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.registerTool(
+      "caliper_clear",
+      {
+        description: "Clear all measurements and selections in the browser UI.",
+        inputSchema: z.object({})
+      },
+      async () => {
+        try {
+          const result = await bridgeService.call(CALIPER_METHODS.CLEAR, {});
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error clearing UI: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.registerTool(
+      "caliper_walk_dom",
+      {
+        description: "Get the semantic context of an element by traversing its parents and children. Useful for understanding component hierarchy.",
+        inputSchema: z.object({
+          selector: z.string().describe(
+            "Element identifier. PRIORITIZE JSON Fingerprint, Caliper Agent ID (caliper-***), or CSS selector for maximum stabilization."
+          )
+        })
+      },
+      async ({ selector }) => {
+        try {
+          const result = await bridgeService.call(CALIPER_METHODS.WALK_DOM, { selector });
+          return { content: [{ type: "text", text: JSON.stringify(result) }] };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `DOM Walk failed: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.registerTool(
+      "caliper_walk_and_measure",
+      {
+        description: `Walk the DOM tree starting from a selector and capture precise measurements.
+
+This is the HARNESS tool for comprehensive audits. It:
+- Walks the DOM tree using BFS (breadth-first) 
+- Captures computed styles for each node (padding, margin, gap, typography, colors)
+- Measures gaps between siblings and distance to parent edges
+- Returns a full tree structure ready for reconciliation with Figma
+
+Use this BEFORE making any code changes to gather complete context.
+ 
+SAFETY: Calling 'caliper_inspect' is REQUIRED before initiating an initial audit on a component. This provides the 'descendantCount' metrics needed to set 'maxNodes' and avoid timeouts. You may skip 'inspect' only when resuming an audit using a 'continuationToken'.
+ 
+STYLE PRUNING: To reduce payload size, default styles are omitted. If a style is missing, assume:
+- display: "block"
+- visibility: "visible"
+- position: "static"
+- boxSizing: "border-box"
+- padding/margin/border: { top: 0, right: 0, bottom: 0, left: 0 }
+- gap: 0
+- flexDirection: "row" (flex only)
+- justifyContent: "normal" (flex only)
+- alignItems: "normal" (flex only)
+- lineHeight: "normal"
+- letterSpacing: "normal"
+- backgroundColor: "rgba(0, 0, 0, 0)" (transparent)
+- borderRadius: "0px"
+- boxShadow: "none"
+- opacity: 1
+- overflow/overflowX/overflowY: "visible"
+
+The output includes:
+- root: The full measured tree (recursive CaliperNode structure)
+- nodeCount: Total nodes captured
+- maxDepthReached: Deepest level reached
+- walkDurationMs: Time taken to complete the walk
+- hasMore: Whether tree was truncated (pagination)
+- continuationToken: Selector to resume from (if hasMore is true)
+- batchInstructions: Guidance for next batch call (if hasMore is true)`,
+        inputSchema: z.object({
+          selector: z.string().describe(
+            "Root element identifier. PRIORITIZE JSON Fingerprint, Caliper Agent ID (caliper-***), or CSS selector for maximum stabilization."
+          ),
+          maxDepth: z.number().optional().describe("Maximum depth to walk (default: 5)"),
+          maxNodes: z.number().optional().describe(
+            "Maximum nodes to return per batch (default: unlimited). Use for large trees."
+          ),
+          continueFrom: z.string().optional().describe("Continuation token from previous call to resume pagination"),
+          minElementSize: z.number().optional().describe(
+            "Minimum element size (width/height) to include in the walk (default: 0). Use to filter out icons or tiny decorative elements."
+          ),
+          ignoreSelectors: z.array(z.string()).optional().describe("List of CSS selectors or Agent IDs to skip during the walk.")
+        })
+      },
+      async ({ selector, maxDepth, maxNodes, continueFrom, minElementSize, ignoreSelectors }) => {
+        try {
+          const auditResult = await bridgeService.call(CALIPER_METHODS.WALK_AND_MEASURE, {
+            selector,
+            maxDepth: maxDepth ?? 5,
+            maxNodes,
+            continueFrom,
+            minElementSize,
+            ignoreSelectors
+          });
+          const auditResponse = auditResult;
+          let reportContent = JSON.stringify(auditResult);
+          if (auditResponse.walkResult?.hasMore && auditResponse.walkResult?.batchInstructions) {
+            reportContent = `${auditResponse.walkResult.batchInstructions}
+
+${reportContent}`;
+          }
+          return { content: [{ type: "text", text: reportContent }] };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Walk and Measure failed: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.registerTool(
+      "caliper_get_context",
+      {
+        description: "Get comprehensive window, viewport, and accessibility metrics from the current browser tab.",
+        inputSchema: z.object({})
+      },
+      async () => {
+        try {
+          const result = await bridgeService.call(CALIPER_METHODS.GET_CONTEXT, {});
+          return { content: [{ type: "text", text: JSON.stringify(result) }] };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Get Context failed: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.registerTool(
+      "caliper_check_contrast",
+      {
+        description: `Check WCAG 2.1 contrast ratio between two colors.
+
+Returns the contrast ratio (1-21) and pass/fail status for:
+- AA Normal Text (4.5:1)
+- AA Large Text (3:1)
+- AAA Normal Text (7:1)
+- AAA Large Text (4.5:1)`,
+        inputSchema: z.object({
+          foreground: z.string().describe("Foreground color (any CSS format: hex, rgb, hsl, oklch, etc.)"),
+          background: z.string().describe("Background color (any CSS format: hex, rgb, hsl, oklch, etc.)")
+        })
+      },
+      async ({ foreground, background }) => {
+        try {
+          const fg = parseColor(foreground);
+          const bg = parseColor(background);
+          const ratio = calculateContrastRatio(fg, bg);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    foreground,
+                    background,
+                    ratio: Number(ratio.toFixed(2)),
+                    passAA: ratio >= 4.5,
+                    passAALarge: ratio >= 3,
+                    passAAA: ratio >= 7,
+                    passAAALarge: ratio >= 4.5
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Contrast check failed: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.registerTool(
+      "caliper_delta_e",
+      {
+        description: `Calculate perceptual color difference (Delta E) between two colors using Oklab.
+
+Returns the Delta E value and a human-readable interpretation:
+- < 0.02: Imperceptible
+- 0.02-0.05: Just noticeable
+- 0.05-0.1: Noticeable
+- 0.1-0.3: Distinct
+- > 0.3: Very different`,
+        inputSchema: z.object({
+          color1: z.string().describe("First color (any CSS format: hex, rgb, hsl, oklch, etc.)"),
+          color2: z.string().describe("Second color (any CSS format: hex, rgb, hsl, oklch, etc.)")
+        })
+      },
+      async ({ color1, color2 }) => {
+        try {
+          const c1 = parseColor(color1);
+          const c2 = parseColor(color2);
+          const deltaE = calculateDeltaE(c1, c2);
+          let interpretation;
+          if (deltaE < 0.02) interpretation = "Imperceptible (< 0.02)";
+          else if (deltaE < 0.05) interpretation = "Just noticeable (0.02-0.05)";
+          else if (deltaE < 0.1) interpretation = "Noticeable (0.05-0.1)";
+          else if (deltaE < 0.3) interpretation = "Distinct (0.1-0.3)";
+          else interpretation = "Very different (> 0.3)";
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    color1,
+                    color2,
+                    deltaE: Number(deltaE.toFixed(4)),
+                    interpretation
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Delta E calculation failed: ${error instanceof Error ? error.message : String(error)}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  registerResources() {
+    this.server.registerResource(
+      "caliper-tabs",
+      "caliper://tabs",
+      { description: "List of all browser tabs currently connected to the bridge." },
+      async () => {
+        const tabs = tabManager.getAllTabs().map((tab) => ({
+          id: tab.id,
+          title: tab.title,
+          url: tab.url,
+          isActive: tab.id === tabManager.getActiveTab()?.id
+        }));
+        return {
+          contents: [
+            {
+              uri: "caliper://tabs",
+              mimeType: "application/json",
+              text: JSON.stringify(tabs, null, 2)
+            }
+          ]
+        };
+      }
+    );
+    this.server.registerResource(
+      "caliper-state",
+      "caliper://state",
+      {
+        description: `Provides a real-time stream of the active browser environment. This is your primary source for "listening" to what the user is doing. 
+        
+        It contains:
+        - viewport: Current scroll positions and dimensions.
+        - activeSelection: Visual metadata of the currently selected element.
+        - selectionFingerprint: A stable JSON identifier (agentId, tag, text content) for the active selection. Use the 'selector' property from this object as input for 'caliper_inspect' or 'caliper_walk_and_measure' to perform high-precision audits on what the user just picked.
+        - lastMeasurement & measurementFingerprint: Context for the most recent distance measurement between two elements.
+        
+        USE CASE: When you receive a notification that this resource has updated, read it to understand the user's current focus. If a 'selectionFingerprint' is present, you can immediately offer to 'Inspect' or 'Audit' that element without asking the user for a selector.`
+      },
+      async () => {
+        return {
+          contents: [
+            {
+              uri: "caliper://state",
+              mimeType: "application/json",
+              text: JSON.stringify(this.lastState, null, 2)
+            }
+          ]
+        };
+      }
+    );
+    bridgeService.on(BRIDGE_EVENTS.STATE, (state) => {
+      this.lastState = state;
+      this.server.server.sendResourceUpdated({ uri: "caliper://state" }).catch((error) => {
+        logger4.warn("Failed to notify resource update", error);
+      });
+    });
+  }
+  registerPrompts() {
+    this.server.registerPrompt(
+      "caliper-selector-audit",
+      {
+        description: "Perform a comprehensive, structured audit of a specific selector: from source discovery to precision styling analysis.",
+        argsSchema: {
+          selector: z.string().describe(
+            "The Caliper Selector (JSON Fingerprint, Caliper Agent ID (caliper-***), or CSS selector) to audit. PRIORITIZE JSON Fingerprint for maximum stabilization."
+          )
+        }
+      },
+      async ({ selector }) => ({
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `## CALIPER SELECTOR AUDIT: ${selector}
+
+You are about to perform a structured, comprehensive audit of the element '${selector}'. Follow these phases precisely.
+
+### PHASE 1: CONTEXT GATHERING
+1. **Deep Inspection**: Call 'caliper_inspect' to get all computed styles, colors, typography, and **sourceHints**.
+2. **Hierarchy Walk**: Call 'caliper_walk_and_measure' with maxDepth: 5 to understand its position in the tree, its children, and the spacing (gaps) to its neighbors.
+3. **Source Discovery**: Use the \`suggestedGrep\` from \`sourceHints\` (or another stable anchor) to locate the exact source file and line number in the codebase.
+
+### PHASE 2: ANALYSIS & CONSISTENCY
+4. **Spacing Check**: Analyze if padding, margins, and gaps follow a consistent scale (e.g., multiples of 4px/8px).
+5. **System Alignment**: Check if font sizes, weights, and colors match the project's design system or established patterns.
+6. **Intent Audit**: Identify hardcoded "magic numbers", layout inconsistencies, or unusual offsets.
+
+### PHASE 3: REMEDIATION
+7. **Recommendations**: Provide a clear report of discrepancies and the exact CSS/Code fixes needed.
+8. **Verification**: After applying changes, re-run 'caliper_inspect' or 'caliper_walk_and_measure' to confirm parity.
+
+---
+BEGIN PHASE 1 NOW. Do not skip any steps.`
+            }
+          }
+        ]
+      })
+    );
+    this.server.registerPrompt(
+      "caliper-selectors-compare",
+      {
+        description: "Compare two selections (A and B) to learn from A and fix B. Supports cross-tab comparisons.",
+        argsSchema: {
+          selectorA: z.string().describe(
+            "Caliper Selector for the REFERENCE element. PRIORITIZE JSON Fingerprint, Caliper Agent ID (caliper-***), or CSS selector for stabilization."
+          ),
+          selectorB: z.string().describe(
+            "Caliper Selector for the TARGET element. PRIORITIZE JSON Fingerprint, Caliper Agent ID (caliper-***), or CSS selector for stabilization."
+          ),
+          tabIdA: z.string().optional().describe("Tab ID containing Selection A (use caliper_list_tabs to find IDs)"),
+          tabIdB: z.string().optional().describe("Tab ID containing Selection B (defaults to same tab as A)"),
+          properties: z.array(z.enum(["spacing", "typography", "colors", "layout", "all"])).default(["all"]).describe("Which properties to compare")
+        }
+      },
+      async ({ selectorA, selectorB, tabIdA, tabIdB, properties }) => ({
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `## CALIPER SELECTORS COMPARISON
+
+You are comparing TWO elements to understand the styling of one (A) and apply corrections to the other (B).
+
+**Inputs:**
+- Selection A (REFERENCE): \`${selectorA}\`${tabIdA ? ` in Tab: ${tabIdA}` : ""}
+- Selection B (TARGET): \`${selectorB}\`${tabIdB ? ` in Tab: ${tabIdB}` : " (same tab as A)"}
+- Properties to Compare: ${properties.join(", ")}
+
+---
+
+### IMPORTANT: TAB MANAGEMENT
+
+${tabIdA || tabIdB ? `
+You are working across multiple tabs. The agent-ID is **tab-specific** - if you send a command to the wrong tab, it will fail.
+
+**Before Each Command:**
+1. Use \`caliper_list_tabs\` to see all connected tabs
+2. Use \`caliper_switch_tab\` to switch to the correct tab BEFORE calling walk/inspect
+` : `
+Both selections are on the SAME tab. No tab switching required.
+`}
+
+### PHASE 1: WALK SELECTION A (REFERENCE)
+
+${tabIdA ? `1. **Switch to Tab A**
+   Call \`caliper_switch_tab\` with tabId: "${tabIdA}"
+
+2. ` : "1. "}**Walk and Measure A**
+   Call \`caliper_walk_and_measure\` with:
+   - selector: "${selectorA}"
+   - maxDepth: 5
+
+   Record A's styles as the REFERENCE:
+   ${properties.includes("all") || properties.includes("spacing") ? "- padding, margin, gap values" : ""}
+   ${properties.includes("all") || properties.includes("typography") ? "- font-size, font-weight, line-height" : ""}
+   ${properties.includes("all") || properties.includes("colors") ? "- background-color, color, border-color" : ""}
+   ${properties.includes("all") || properties.includes("layout") ? "- display, flex-direction, justify-content, align-items" : ""}
+
+### PHASE 2: WALK SELECTION B (TARGET)
+
+${tabIdB ? `${tabIdA ? "3" : "2"}. **Switch to Tab B**
+   Call \`caliper_switch_tab\` with tabId: "${tabIdB}"
+
+${tabIdA ? "4" : "3"}. ` : `${tabIdA ? "3" : "2"}. `}**Walk and Measure B**
+   Call \`caliper_walk_and_measure\` with:
+   - selector: "${selectorB}"
+   - maxDepth: 5
+
+### PHASE 3: COMPARE AND ANALYZE
+
+${tabIdB ? tabIdA ? "5" : "4" : tabIdA ? "4" : "3"}. **Generate Comparison Report**
+   For each property category, list:
+   - Property name
+   - Value in A (REFERENCE)
+   - Value in B (TARGET)
+   - Delta (difference)
+   - Recommended fix for B
+
+   Focus on making B match A's styling approach.
+
+### PHASE 4: FIND SOURCE FOR B
+
+${tabIdB ? tabIdA ? "6" : "5" : tabIdA ? "5" : "4"}. **Locate B's Source**
+   ${tabIdB ? `Switch back to Tab B if needed.` : ""}
+   Use internal agent search (grep) with B's best anchor.
+   Get the exact file path and line number.
+
+### PHASE 5: APPLY FIXES TO B
+
+${tabIdB ? tabIdA ? "7" : "6" : tabIdA ? "6" : "5"}. **Generate CSS Fixes**
+   Create CSS rules that will make B match A:
+   \`\`\`css
+   ${selectorB.startsWith("#") ? selectorB : `.${selectorB}`} {
+     /* Fixes to match Selection A */
+   }
+   \`\`\`
+
+${tabIdB ? tabIdA ? "8" : "7" : tabIdA ? "7" : "6"}. **Edit Source File**
+   Apply the CSS fixes to B's source file.
+
+${tabIdB ? tabIdA ? "9" : "8" : tabIdA ? "8" : "7"}. **Verify**
+   Re-run \`caliper_walk_and_measure\` on B to confirm the fix.
+
+---
+**BEGIN PHASE 1 NOW. Remember to switch tabs before each walk command if working across tabs.**`
+            }
+          }
+        ]
+      })
+    );
+  }
+  async start() {
+    try {
+      await bridgeService.start(this.port);
+    } catch (err) {
+      logger4.error("Bridge startup failed:", err);
+    }
+    try {
+      const transport = new StdioServerTransport();
+      await this.server.connect(transport);
+      logger4.info("Server running on STDIO transport");
+    } catch (err) {
+      logger4.error("MCP Startup failed:", err);
+      process.exit(1);
+    }
+  }
+  async stop() {
+    await bridgeService.stop();
+    logger4.info("Server stopped.");
+  }
+};
+
+// ../mcp-server/src/index.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let port2 = DEFAULT_BRIDGE_PORT;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" || args[i] === "-p") {
+      const nextArg = args[i + 1];
+      if (nextArg) {
+        const val = parseInt(nextArg, 10);
+        if (!isNaN(val) && val > 0 && val < 65536) {
+          port2 = val;
+        }
+      }
+      i++;
+    } else if (args[i] === "--help" || args[i] === "-h") {
+      console.error(`
+Caliper MCP Server - AI-powered UI measurement tool
+
+Usage:
+  npx @oyerinde/caliper-mcp [options]
+
+Options:
+  -p, --port <number>  WebSocket relay port (default: ${DEFAULT_BRIDGE_PORT})
+  -d, --docs           Open documentation: https://caliper.danieloyerinde.com/
+  -h, --help           Show this help message
+`);
+      process.exit(0);
+    } else if (args[i] === "--docs" || args[i] === "-d") {
+      console.log("\n\u{1F4DA} View Documentation: https://caliper.danieloyerinde.com/\n");
+      process.exit(0);
+    }
+  }
+  return { port: port2 };
+}
+var { port } = parseArgs();
+var server = new CaliperMcpServer(port);
+server.start();
+var shutdown = async () => {
+  await server.stop();
+  process.exit(0);
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.stdin.on("end", shutdown);