Read 2D objects with their exact geometry and attributes.

Scope: uuids, or selection=True, or layer ("*" = all design layers), optionally filtered by class_name. Default: the active layer. Geometry is exact, in document units: polygons/polylines give vertices [x, y, type, radius] (type 0 corner, 3 arc control vertex) plus holes, rects give corners/angle, arcs center/radius/start_angle/sweep, lines p1/p2, texts origin/size/font. Objects inside groups are listed after their group with "parent". bbox [x1, y1, x2, y2] limits the read to an area.

Layers and classes of the document and how they are used: objects per layer and class, class attributes, and organisation problems (objects in the none class, unused classes, empty layers, objects with their own attributes instead of 'by class', dimensions/texts outside their classes, inconsistent design layer scales). Read this before drawing so new objects follow the document's structure.

List hatches or line types (document + Vectorworks default content, imported automatically when used), or classes / layers of the document. query filters by substring, e.g. "Beton", "ISO-02".

Create or update classes and design layers so drawings are organised.

classes: [{"name": "Wand-Tragend", "attributes": {"pen": "#000000", "fill": "#000000" | "none", "hatch": "Beton SRF", "line_weight": 0.5 (mm), "line_style": "solid" | "ISO-02 Strichlinie", "opacity": 100}}]. Class attributes are what objects use 'by class' (the default for new objects). Use "-" for class hierarchy ("Wand-Tragend"). layers: [{"name": "EG", "scale": 100}] (design layers, scale 1:100). template "architektur": a starting set of German architecture classes (walls, columns, openings, stairs, furniture, axes, dimensions, text...); only use it if the document has no class standard yet and the user agrees. Existing classes keep their name; given attributes are applied.

Draw exact 2D objects (all or nothing, one undo step).

Each item has a "type" plus geometry; optional "class", "layer", "name", "attributes", "unit" override the call-level defaults:

• polygon / polyline: {"points": [[x, y], ...], "relative": false, "holes": [[[x, y], ...]]}. relative=true: points after the first are offsets (exact decimal sums, like a Maßkette).

• path (lines + true arcs): {"start": [x, y], "segments": [ {"line_to": [x, y]}, {"arc_to": [x, y], "center": [cx, cy], "direction": "ccw"|"cw"} | {"arc_to": [x, y], "through": [x, y]} | {"arc_to": [x, y], "radius": r, "direction": "ccw", "large": false}], "closed": true, "holes": [path or points]}

• rect: {"corner": [x, y], "width": w, "height": h, "angle": 0} or {"p1": [x, y], "p2": [x, y]}

• circle {"center", "radius"}; arc {"center", "radius", "start_angle", "sweep"} or {"start", "through", "end"}; oval {"center", "width", "height", "angle"}; line {"p1", "p2"}; locus {"point"}

• text {"text", "position", "size" (pt), "font", "align" left|center|right, "valign" top|center|baseline|bottom, "angle"}

• dimension {"p1", "p2", "offset", "orientation" horizontal|vertical|aligned}; chain_dimension {"points": [...], ...} attributes: pen, fill ("none" or "#rrggbb"), hatch (name), line_style, line_weight (mm), opacity; without any, everything is 'by class'. Every object needs a class (class_name or per item) unless allow_no_class=True. Returns each object's uuid and its exactness (deviation between request and what Vectorworks stored), plus any check issues involving the new objects.

Replace the outline of a polygon/polyline/rect exactly.

Give one of: points [[x, y], ...] (corners), path (same format as vw2d_draw paths, lines + true arcs) or raw vertices [[x, y, type, radius]] as returned by vw2d_read. holes: list of point lists or paths. Same vertex count and no holes: edited in place (uuid stays), otherwise rebuilt with the same class, attributes, name, group and stacking position (new uuid returned). One undo step.

Move, rotate, mirror or scale objects (copy=True keeps the originals).

move: dx/dy, or from_point -> to_point (exact difference, e.g. a corner onto another object's corner); rotate: center + angle (degrees, ccw); mirror: axis [[x1, y1], [x2, y2]]; scale: center + sx (+ sy). One undo step.

Exact area operations (Vectorworks/Parasolid, arcs stay arcs): union (targets + tools become ONE area, e.g. a ring from its pieces), subtract (tools cut out of each target, tools stay unless keep_tools=False), intersect, split (each target cut by the line split_line [[x1, y1], [x2, y2]]). Results keep the first target's class and attributes; floating-point noise is snapped back to the exact input coordinates. One undo step.

Offset a polygon/polyline outline by distance (positive = outwards for counter-clockwise outlines), e.g. wall thickness or a plaster layer. replace=True swaps the original for the result.

Change class, layer or graphic attributes of objects.

class_name: put the objects into this class (created if missing). layer: move them to this design layer. attributes: pen, fill ("none" | "#rrggbb"), hatch, line_style, line_weight (mm), opacity, name, or {"by_class": true} to make every graphic attribute follow the class (recommended). Any single value "class" = that attribute by class. One undo step.

Delete objects (restorable with vw_revert_last).

Check drawing quality on the exact geometry and return a report (and a check image with numbered issues).

Finds: overlaps and stacked fills, gaps and slivers between neighbours, points that miss each other or an edge by up to tolerance_mm, duplicates, double lines, open or self-intersecting outlines, duplicate/redundant vertices, slivers and tiny objects, objects without class, attributes not 'by class'. Overlaps/gaps are compared between objects on the same layer (compare="layer"), the same class ("class") or everything ("all"); ignore_classes (e.g. ["Ausstattung*", "Schraffur"]) leaves out classes that overlap on purpose. checks: subset of overlap, duplicate, near, gap, self_intersection, open, double_line, vertices, tiny, classes, attributes, approx. Each issue suggests a vw2d_fix action. bbox [x1, y1, x2, y2] checks only objects touching that area (fast on big drawings). Precision: 0.005 mm; distances are measured on true arcs.

Check image of a scope, rendered from the exact geometry with issues marked (red errors, orange warnings, arrows = where vw2d_fix snap would move a point). focus_issue zooms to one issue id from vw2d_check; bbox [x1, y1, x2, y2] shows (and checks) only that area (document units).

Fix check issues exactly, then check again (one undo step).

snap: points that miss a vertex/edge by <= tolerance_mm move exactly onto it (gaps and small overlaps disappear); objects in fixed never move; share_vertices inserts the point into the neighbour's edge so both share the node. Arcs keep their circle. close: close open outlines (end point merged with the start if within the tolerance). clean: remove duplicate and collinear vertices (merge_short=True also merges vertices closer than the tolerance). duplicates: delete duplicate areas/lines (the top copy stays). overlaps: clip overlapping areas: priority (uuids or class names, first wins) keeps its area; without priority the object on top wins, so the drawing looks the same but has no stacked fills. merge: union all objects in scope (or uuids) into one area. by_class: set every graphic attribute of the scoped objects to 'by class'. issue_ids limits the fix to issues from the last vw2d_check with the same scope/settings.

Select objects in Vectorworks (and zoom to them) so the user sees what was drawn or changed.

Check the Vectorworks bridge: returns Vectorworks version, active document and bridge version. Warns if the installed bridge doesn't match this server.

Run arbitrary Python inside Vectorworks with vs in scope.

Returns stdout, the value of the last expression (or of a variable named result), and the traceback if it raised. Vectorworks embeds Python 3.9. Handles are only valid during the call; return UUIDs (vs.GetObjectUuid) to refer to objects later. A wrong vs.* signature can pop a modal "Script Errors" dialog in Vectorworks instead of raising; check with vw_vs_lookup first. Set modifies_document=False for read-only code; otherwise vw_revert_last can't step past this call.

Search the live vs.* API (names and built-in docs) of the running Vectorworks, e.g. "record field", "symbol insert", "LDevice". Returns function names with their signature/description.

Active document: name, path, units, active layer/class, counts, selection size.

All layers (design and sheet) with visibility and which one is active.

All class names, optionally filtered by a case-insensitive substring.

Selected objects on the active layer: uuid, type, name, class, layer, bbox, attached records, and symbol / plug-in name where relevant.

Find objects by any combination of exact class, layer, type ("Symbol", "Rectangle", "Plug-in Object"...), plug-in name ("Lighting Device"), attached record (optionally with field == value) and object name.

All field values of a record (or a plug-in object's parameters, using its plug-in name as the record) on the object with this UUID.

Set record fields (or plug-in parameters) on one object; unknown field names are rejected before anything changes. One undo step. Returns the record afterwards.

Symbol definitions in the document's resource list, with their folder path; filter by name and/or folder substring (e.g. fixture lookup).

Place a symbol from the document's resources at x, y (document units), optionally at height z, on a layer and in a class. One undo step.

Undo exactly the last MCP write in the active document: deletes what a tool created, restores objects a tool changed or deleted (geometry, attributes, class, name, group and stacking position) and restores record fields. Call repeatedly to step further back. (Vectorworks' own Cmd-Z merges consecutive MCP edits.) Raw vw_exec_python edits can't be reverted this way. Restored objects get new UUIDs (returned in mapping).