@genart-dev/plugin-construction 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2900 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  approximateIntersection: () => approximateIntersection,
+  castShadow: () => castShadow,
+  clamp: () => clamp,
+  comparativeMeasure: () => comparativeMeasure,
+  computeEnvelope: () => computeEnvelope,
+  constructionMcpTools: () => constructionMcpTools,
+  cross3: () => cross3,
+  crossContourLayerType: () => crossContourLayerType,
+  default: () => index_default,
+  dot3: () => dot3,
+  drawEllipse: () => drawEllipse,
+  drawEllipseWithHidden: () => drawEllipseWithHidden,
+  ellipsePoints: () => ellipsePoints,
+  envelopeAngles: () => envelopeAngles,
+  envelopeLayerType: () => envelopeLayerType,
+  formLayerType: () => formLayerType,
+  identityMatrix: () => identityMatrix,
+  intersectionLayerType: () => intersectionLayerType,
+  levelLine: () => levelLine,
+  lightDirection: () => lightDirection,
+  lightDirection2D: () => lightDirection2D,
+  multiplyMat3: () => multiplyMat3,
+  normalize3: () => normalize3,
+  plumbLine: () => plumbLine,
+  project: () => project,
+  projectedEllipse: () => projectedEllipse,
+  rotate3D: () => rotate3D,
+  rotationMatrix: () => rotationMatrix,
+  sphereTerminator: () => sphereTerminator,
+  sphereValueZones: () => sphereValueZones,
+  transformPoint: () => transformPoint,
+  transformedNormalZ: () => transformedNormalZ,
+  valueShapesLayerType: () => valueShapesLayerType
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/shared.ts
+var COMMON_GUIDE_PROPERTIES = [
+  {
+    key: "guideColor",
+    label: "Guide Color",
+    type: "color",
+    default: "rgba(0,200,255,0.5)",
+    group: "style"
+  },
+  {
+    key: "lineWidth",
+    label: "Line Width",
+    type: "number",
+    default: 1,
+    min: 0.5,
+    max: 5,
+    step: 0.5,
+    group: "style"
+  },
+  {
+    key: "dashPattern",
+    label: "Dash Pattern",
+    type: "string",
+    default: "6,4",
+    group: "style"
+  }
+];
+function setupGuideStyle(ctx, color, lineWidth, dashPattern) {
+  ctx.strokeStyle = color;
+  ctx.lineWidth = lineWidth;
+  const dashes = dashPattern.split(",").map(Number).filter((n) => !isNaN(n) && n > 0);
+  ctx.setLineDash(dashes.length > 0 ? dashes : [6, 4]);
+}
+function drawLine(ctx, x1, y1, x2, y2) {
+  ctx.beginPath();
+  ctx.moveTo(x1, y1);
+  ctx.lineTo(x2, y2);
+  ctx.stroke();
+}
+function drawDashedLine(ctx, x1, y1, x2, y2, dash) {
+  const saved = ctx.getLineDash();
+  ctx.setLineDash(dash);
+  drawLine(ctx, x1, y1, x2, y2);
+  ctx.setLineDash(saved);
+}
+function drawPolyline(ctx, points, close = false) {
+  if (points.length < 2) return;
+  ctx.beginPath();
+  ctx.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) {
+    ctx.lineTo(points[i].x, points[i].y);
+  }
+  if (close) ctx.closePath();
+  ctx.stroke();
+}
+function fillPolyline(ctx, points, fillStyle) {
+  if (points.length < 3) return;
+  ctx.beginPath();
+  ctx.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) {
+    ctx.lineTo(points[i].x, points[i].y);
+  }
+  ctx.closePath();
+  ctx.fillStyle = fillStyle;
+  ctx.fill();
+}
+function drawLabel(ctx, text, x, y, color, fontSize = 10) {
+  ctx.fillStyle = color;
+  ctx.font = `${fontSize}px sans-serif`;
+  ctx.textAlign = "center";
+  ctx.textBaseline = "middle";
+  ctx.fillText(text, x, y);
+}
+function toPixel(norm, bounds) {
+  return {
+    x: bounds.x + norm.x * bounds.width,
+    y: bounds.y + norm.y * bounds.height
+  };
+}
+function parseJSON(json, fallback) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return fallback;
+  }
+}
+function parseCSVColors(csv, count) {
+  const parts = csv.split(",").map((s) => s.trim());
+  const result = [];
+  const defaults = ["red", "green", "blue"];
+  for (let i = 0; i < count; i++) {
+    result.push(parts[i] || defaults[i % defaults.length]);
+  }
+  return result;
+}
+function applyHiddenEdgeStyle(ctx, style, alpha) {
+  switch (style) {
+    case "dashed":
+      ctx.setLineDash([6, 4]);
+      ctx.globalAlpha = alpha;
+      break;
+    case "dotted":
+      ctx.setLineDash([2, 3]);
+      ctx.globalAlpha = alpha;
+      break;
+    case "faint":
+      ctx.setLineDash([]);
+      ctx.globalAlpha = alpha * 0.5;
+      break;
+    case "hidden":
+      ctx.globalAlpha = 0;
+      break;
+  }
+}
+function resetEdgeStyle(ctx, savedAlpha) {
+  ctx.setLineDash([]);
+  ctx.globalAlpha = savedAlpha;
+}
+
+// src/math/rotation.ts
+var DEG2RAD = Math.PI / 180;
+function clamp(v, min, max) {
+  return v < min ? min : v > max ? max : v;
+}
+function rotationMatrix(rxDeg, ryDeg, rzDeg) {
+  const rx = clamp(rxDeg, -90, 90) * DEG2RAD;
+  const ry = ryDeg * DEG2RAD;
+  const rz = rzDeg * DEG2RAD;
+  const cx = Math.cos(rx), sx = Math.sin(rx);
+  const cy = Math.cos(ry), sy = Math.sin(ry);
+  const cz = Math.cos(rz), sz = Math.sin(rz);
+  return [
+    cz * cy,
+    cz * sy * sx - sz * cx,
+    cz * sy * cx + sz * sx,
+    sz * cy,
+    sz * sy * sx + cz * cx,
+    sz * sy * cx - cz * sx,
+    -sy,
+    cy * sx,
+    cy * cx
+  ];
+}
+function rotate3D(point, m) {
+  return {
+    x: m[0] * point.x + m[1] * point.y + m[2] * point.z,
+    y: m[3] * point.x + m[4] * point.y + m[5] * point.z,
+    z: m[6] * point.x + m[7] * point.y + m[8] * point.z
+  };
+}
+function project(point, projection = "orthographic", focalLength = 5) {
+  if (projection === "weak-perspective") {
+    const scale = focalLength / (focalLength + point.z);
+    return { x: point.x * scale, y: point.y * scale };
+  }
+  return { x: point.x, y: point.y };
+}
+function transformPoint(point, rxDeg, ryDeg, rzDeg, projection = "orthographic", focalLength = 5) {
+  const m = rotationMatrix(rxDeg, ryDeg, rzDeg);
+  const rotated = rotate3D(point, m);
+  return project(rotated, projection, focalLength);
+}
+function transformedNormalZ(normal, m) {
+  return m[6] * normal.x + m[7] * normal.y + m[8] * normal.z;
+}
+function identityMatrix() {
+  return [1, 0, 0, 0, 1, 0, 0, 0, 1];
+}
+function multiplyMat3(a, b) {
+  return [
+    a[0] * b[0] + a[1] * b[3] + a[2] * b[6],
+    a[0] * b[1] + a[1] * b[4] + a[2] * b[7],
+    a[0] * b[2] + a[1] * b[5] + a[2] * b[8],
+    a[3] * b[0] + a[4] * b[3] + a[5] * b[6],
+    a[3] * b[1] + a[4] * b[4] + a[5] * b[7],
+    a[3] * b[2] + a[4] * b[5] + a[5] * b[8],
+    a[6] * b[0] + a[7] * b[3] + a[8] * b[6],
+    a[6] * b[1] + a[7] * b[4] + a[8] * b[7],
+    a[6] * b[2] + a[7] * b[5] + a[8] * b[8]
+  ];
+}
+function normalize3(v) {
+  const len = Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+  if (len < 1e-10) return { x: 0, y: 0, z: 0 };
+  return { x: v.x / len, y: v.y / len, z: v.z / len };
+}
+function dot3(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function cross3(a, b) {
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
+}
+function dist2(a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function lerp2(a, b, t) {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+
+// src/math/ellipse.ts
+var DEG2RAD2 = Math.PI / 180;
+function projectedEllipse(center, radius, normalTilt, axisRotation) {
+  const tiltRad = normalTilt * DEG2RAD2;
+  const minor = radius * Math.abs(Math.cos(tiltRad));
+  return {
+    cx: center.x,
+    cy: center.y,
+    rx: radius,
+    ry: minor,
+    rotation: axisRotation * DEG2RAD2
+  };
+}
+function drawEllipse(ctx, cx, cy, rx, ry, rotation, startAngle = 0, endAngle = Math.PI * 2, counterclockwise = false) {
+  ctx.beginPath();
+  ctx.ellipse(cx, cy, Math.abs(rx), Math.abs(ry), rotation, startAngle, endAngle, counterclockwise);
+  ctx.stroke();
+}
+function drawEllipseWithHidden(ctx, params, frontHalf, hiddenAlpha, hiddenDash) {
+  const { cx, cy, rx, ry, rotation } = params;
+  if (rx < 0.5 || ry < 0.5) return;
+  const savedAlpha = ctx.globalAlpha;
+  const savedDash = ctx.getLineDash();
+  ctx.beginPath();
+  ctx.ellipse(cx, cy, rx, ry, rotation, frontHalf[0], frontHalf[1], false);
+  ctx.stroke();
+  ctx.globalAlpha = hiddenAlpha;
+  ctx.setLineDash(hiddenDash);
+  ctx.beginPath();
+  ctx.ellipse(cx, cy, rx, ry, rotation, frontHalf[1], frontHalf[0] + Math.PI * 2, false);
+  ctx.stroke();
+  ctx.globalAlpha = savedAlpha;
+  ctx.setLineDash(savedDash);
+}
+function ellipsePoints(params, segments, startAngle = 0, endAngle = Math.PI * 2) {
+  const { cx, cy, rx, ry, rotation } = params;
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const points = [];
+  for (let i = 0; i <= segments; i++) {
+    const t = i / segments;
+    const angle = startAngle + (endAngle - startAngle) * t;
+    const px = rx * Math.cos(angle);
+    const py = ry * Math.sin(angle);
+    points.push({
+      x: cx + px * cos - py * sin,
+      y: cy + px * sin + py * cos
+    });
+  }
+  return points;
+}
+
+// src/forms/box.ts
+var BOX_VERTICES = [
+  { x: -0.5, y: -0.5, z: -0.5 },
+  // 0: left-bottom-back
+  { x: 0.5, y: -0.5, z: -0.5 },
+  // 1: right-bottom-back
+  { x: 0.5, y: 0.5, z: -0.5 },
+  // 2: right-top-back
+  { x: -0.5, y: 0.5, z: -0.5 },
+  // 3: left-top-back
+  { x: -0.5, y: -0.5, z: 0.5 },
+  // 4: left-bottom-front
+  { x: 0.5, y: -0.5, z: 0.5 },
+  // 5: right-bottom-front
+  { x: 0.5, y: 0.5, z: 0.5 },
+  // 6: right-top-front
+  { x: -0.5, y: 0.5, z: 0.5 }
+  // 7: left-top-front
+];
+var FACE_NORMALS = [
+  { x: 0, y: 0, z: 1 },
+  // 0: front
+  { x: 0, y: 0, z: -1 },
+  // 1: back
+  { x: 1, y: 0, z: 0 },
+  // 2: right
+  { x: -1, y: 0, z: 0 },
+  // 3: left
+  { x: 0, y: 1, z: 0 },
+  // 4: top
+  { x: 0, y: -1, z: 0 }
+  // 5: bottom
+];
+var BOX_EDGES = [
+  // Front face edges
+  { a: 4, b: 5, faces: [0, 5] },
+  // front-bottom
+  { a: 5, b: 6, faces: [0, 2] },
+  // front-right
+  { a: 6, b: 7, faces: [0, 4] },
+  // front-top
+  { a: 7, b: 4, faces: [0, 3] },
+  // front-left
+  // Back face edges
+  { a: 0, b: 1, faces: [1, 5] },
+  // back-bottom
+  { a: 1, b: 2, faces: [1, 2] },
+  // back-right
+  { a: 2, b: 3, faces: [1, 4] },
+  // back-top
+  { a: 3, b: 0, faces: [1, 3] },
+  // back-left
+  // Connecting edges (front-to-back)
+  { a: 4, b: 0, faces: [3, 5] },
+  // left-bottom
+  { a: 5, b: 1, faces: [2, 5] },
+  // right-bottom
+  { a: 6, b: 2, faces: [2, 4] },
+  // right-top
+  { a: 7, b: 3, faces: [3, 4] }
+  // left-top
+];
+function isEdgeFrontFacing(edge, faceVisibility) {
+  return faceVisibility[edge.faces[0]] || faceVisibility[edge.faces[1]];
+}
+function renderBox(ctx, opts) {
+  const { center, scale, sizeX, sizeY, sizeZ, matrix, projection, focalLength, showHidden, hiddenStyle, hiddenAlpha, edgeColor } = opts;
+  const projected = BOX_VERTICES.map((v) => {
+    const scaled = { x: v.x * sizeX, y: v.y * sizeY, z: v.z * sizeZ };
+    const rotated = rotate3D(scaled, matrix);
+    const p = project(rotated, projection, focalLength);
+    return { x: center.x + p.x * scale, y: center.y - p.y * scale };
+  });
+  const faceVisibility = FACE_NORMALS.map((n) => transformedNormalZ(n, matrix) > 0);
+  ctx.strokeStyle = edgeColor;
+  const savedAlpha = ctx.globalAlpha;
+  if (showHidden) {
+    applyHiddenEdgeStyle(ctx, hiddenStyle, hiddenAlpha);
+    for (const edge of BOX_EDGES) {
+      if (!isEdgeFrontFacing(edge, faceVisibility)) {
+        const pa = projected[edge.a];
+        const pb = projected[edge.b];
+        drawLine(ctx, pa.x, pa.y, pb.x, pb.y);
+      }
+    }
+    resetEdgeStyle(ctx, savedAlpha);
+  }
+  ctx.setLineDash([]);
+  ctx.globalAlpha = savedAlpha;
+  for (const edge of BOX_EDGES) {
+    if (isEdgeFrontFacing(edge, faceVisibility)) {
+      const pa = projected[edge.a];
+      const pb = projected[edge.b];
+      drawLine(ctx, pa.x, pa.y, pb.x, pb.y);
+    }
+  }
+  return projected;
+}
+function boxCrossContours(opts, count) {
+  const { center, scale, sizeX, sizeY, sizeZ, matrix, projection, focalLength } = opts;
+  const faceVisibility = FACE_NORMALS.map((n) => transformedNormalZ(n, matrix) > 0);
+  const front = [];
+  const hidden = [];
+  const faceContours = [
+    // Front/back faces: horizontal lines
+    { faceIdx: 0, generate: () => generateFaceContours(sizeX, sizeY, 0.5 * sizeZ, "xy", count) },
+    { faceIdx: 1, generate: () => generateFaceContours(sizeX, sizeY, -0.5 * sizeZ, "xy", count) },
+    // Right/left faces: horizontal lines
+    { faceIdx: 2, generate: () => generateFaceContours(sizeZ, sizeY, 0.5 * sizeX, "zy-right", count) },
+    { faceIdx: 3, generate: () => generateFaceContours(sizeZ, sizeY, -0.5 * sizeX, "zy-left", count) },
+    // Top/bottom faces: depth lines
+    { faceIdx: 4, generate: () => generateFaceContours(sizeX, sizeZ, 0.5 * sizeY, "xz-top", count) },
+    { faceIdx: 5, generate: () => generateFaceContours(sizeX, sizeZ, -0.5 * sizeY, "xz-bottom", count) }
+  ];
+  for (const fc of faceContours) {
+    const lines3D = fc.generate();
+    const lines2D = lines3D.map(
+      (line) => line.map((p) => {
+        const rotated = rotate3D(p, matrix);
+        const proj = project(rotated, projection, focalLength);
+        return { x: center.x + proj.x * scale, y: center.y - proj.y * scale };
+      })
+    );
+    if (faceVisibility[fc.faceIdx]) {
+      front.push(...lines2D);
+    } else {
+      hidden.push(...lines2D);
+    }
+  }
+  return { front, hidden };
+}
+function generateFaceContours(width, height, fixedCoord, plane, count) {
+  const lines = [];
+  for (let i = 1; i < count; i++) {
+    const t = i / count - 0.5;
+    const line = [];
+    switch (plane) {
+      case "xy":
+        line.push({ x: -width / 2, y: t * height, z: fixedCoord });
+        line.push({ x: width / 2, y: t * height, z: fixedCoord });
+        break;
+      case "zy-right":
+        line.push({ x: fixedCoord, y: t * height, z: -width / 2 });
+        line.push({ x: fixedCoord, y: t * height, z: width / 2 });
+        break;
+      case "zy-left":
+        line.push({ x: fixedCoord, y: t * height, z: -width / 2 });
+        line.push({ x: fixedCoord, y: t * height, z: width / 2 });
+        break;
+      case "xz-top":
+        line.push({ x: -width / 2, y: fixedCoord, z: t * height });
+        line.push({ x: width / 2, y: fixedCoord, z: t * height });
+        break;
+      case "xz-bottom":
+        line.push({ x: -width / 2, y: fixedCoord, z: t * height });
+        line.push({ x: width / 2, y: fixedCoord, z: t * height });
+        break;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+// src/forms/cylinder.ts
+function projectVertex(v, opts) {
+  const rotated = rotate3D(v, opts.matrix);
+  const p = project(rotated, opts.projection, opts.focalLength);
+  return { x: opts.center.x + p.x * opts.scale, y: opts.center.y - p.y * opts.scale };
+}
+function cylinderEllipseAt(yPos, opts) {
+  const { matrix, center, scale, sizeX, sizeZ } = opts;
+  const center3D = { x: 0, y: yPos, z: 0 };
+  const center2D = projectVertex(center3D, opts);
+  const yAxisRotated = rotate3D({ x: 0, y: 1, z: 0 }, matrix);
+  const topSideVisible = yAxisRotated.z > 0;
+  const px = projectVertex({ x: sizeX * 0.5, y: yPos, z: 0 }, opts);
+  const pz = projectVertex({ x: 0, y: yPos, z: sizeZ * 0.5 }, opts);
+  const ax = Math.sqrt((px.x - center2D.x) ** 2 + (px.y - center2D.y) ** 2);
+  const az = Math.sqrt((pz.x - center2D.x) ** 2 + (pz.y - center2D.y) ** 2);
+  const angle = Math.atan2(px.y - center2D.y, px.x - center2D.x);
+  const topP = projectVertex({ x: 0, y: opts.sizeY / 2, z: 0 }, opts);
+  const botP = projectVertex({ x: 0, y: -opts.sizeY / 2, z: 0 }, opts);
+  const axisDir = {
+    x: topP.x - botP.x,
+    y: topP.y - botP.y
+  };
+  return {
+    params: { cx: center2D.x, cy: center2D.y, rx: Math.max(ax, az), ry: Math.min(ax, az), rotation: angle },
+    axisDir,
+    topSideVisible
+  };
+}
+function renderCylinder(ctx, opts) {
+  const { showHidden, hiddenStyle, hiddenAlpha, edgeColor, sizeY } = opts;
+  const halfH = sizeY / 2;
+  ctx.strokeStyle = edgeColor;
+  const savedAlpha = ctx.globalAlpha;
+  const topEllipse = cylinderEllipseAt(halfH, opts);
+  const botEllipse = cylinderEllipseAt(-halfH, opts);
+  const hiddenDash = hiddenStyle === "dotted" ? [2, 3] : [6, 4];
+  const topFront = topEllipse.topSideVisible ? [0, Math.PI] : [Math.PI, Math.PI * 2];
+  const botFront = !botEllipse.topSideVisible ? [0, Math.PI] : [Math.PI, Math.PI * 2];
+  const topLeft = ellipsePointAt(topEllipse.params, Math.PI);
+  const topRight = ellipsePointAt(topEllipse.params, 0);
+  const botLeft = ellipsePointAt(botEllipse.params, Math.PI);
+  const botRight = ellipsePointAt(botEllipse.params, 0);
+  ctx.setLineDash([]);
+  ctx.globalAlpha = savedAlpha;
+  drawLine(ctx, topLeft.x, topLeft.y, botLeft.x, botLeft.y);
+  drawLine(ctx, topRight.x, topRight.y, botRight.x, botRight.y);
+  if (showHidden) {
+    drawEllipseWithHidden(ctx, topEllipse.params, topFront, hiddenAlpha, hiddenDash);
+    drawEllipseWithHidden(ctx, botEllipse.params, botFront, hiddenAlpha, hiddenDash);
+  } else {
+    ctx.beginPath();
+    ctx.ellipse(
+      topEllipse.params.cx,
+      topEllipse.params.cy,
+      topEllipse.params.rx,
+      topEllipse.params.ry,
+      topEllipse.params.rotation,
+      topFront[0],
+      topFront[1]
+    );
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.ellipse(
+      botEllipse.params.cx,
+      botEllipse.params.cy,
+      botEllipse.params.rx,
+      botEllipse.params.ry,
+      botEllipse.params.rotation,
+      botFront[0],
+      botFront[1]
+    );
+    ctx.stroke();
+  }
+}
+function cylinderCrossContours(opts, count) {
+  const halfH = opts.sizeY / 2;
+  const contours = [];
+  for (let i = 1; i < count; i++) {
+    const t = i / count;
+    const y = -halfH + t * opts.sizeY;
+    const ellipse = cylinderEllipseAt(y, opts);
+    const frontHalf = ellipse.topSideVisible ? [0, Math.PI] : [Math.PI, Math.PI * 2];
+    contours.push({ params: ellipse.params, frontHalf });
+  }
+  return contours;
+}
+function ellipsePointAt(params, angle) {
+  const cos = Math.cos(params.rotation);
+  const sin = Math.sin(params.rotation);
+  const px = params.rx * Math.cos(angle);
+  const py = params.ry * Math.sin(angle);
+  return {
+    x: params.cx + px * cos - py * sin,
+    y: params.cy + px * sin + py * cos
+  };
+}
+
+// src/forms/sphere.ts
+function projectVertex2(v, opts) {
+  const rotated = rotate3D(v, opts.matrix);
+  const p = project(rotated, opts.projection, opts.focalLength);
+  return { x: opts.center.x + p.x * opts.scale, y: opts.center.y - p.y * opts.scale };
+}
+function renderSphere(ctx, opts) {
+  const { center, scale, radius, edgeColor } = opts;
+  const screenRadius = radius * scale;
+  ctx.strokeStyle = edgeColor;
+  ctx.beginPath();
+  ctx.arc(center.x, center.y, screenRadius, 0, Math.PI * 2);
+  ctx.stroke();
+}
+function sphereCrossContours(opts, latCount, lonCount) {
+  const { center, scale, radius, matrix, projection, focalLength } = opts;
+  const contours = [];
+  const r = radius;
+  for (let i = 1; i < latCount; i++) {
+    const t = i / latCount;
+    const y = -r + t * 2 * r;
+    const circleRadius = Math.sqrt(r * r - y * y);
+    const circleCenter = { x: 0, y, z: 0 };
+    const cc2D = projectVertex2(circleCenter, opts);
+    const px = projectVertex2({ x: circleRadius, y, z: 0 }, opts);
+    const pz = projectVertex2({ x: 0, y, z: circleRadius }, opts);
+    const ax = Math.sqrt((px.x - cc2D.x) ** 2 + (px.y - cc2D.y) ** 2);
+    const az = Math.sqrt((pz.x - cc2D.x) ** 2 + (pz.y - cc2D.y) ** 2);
+    const angle = Math.atan2(px.y - cc2D.y, px.x - cc2D.x);
+    const normalZ = rotate3D({ x: 0, y: 1, z: 0 }, matrix).z;
+    const topVisible = normalZ > 0;
+    const isAboveEquator = y > 0;
+    const frontHalf = isAboveEquator === topVisible ? [0, Math.PI] : [Math.PI, Math.PI * 2];
+    contours.push({
+      params: { cx: cc2D.x, cy: cc2D.y, rx: Math.max(ax, az), ry: Math.min(ax, az), rotation: angle },
+      frontHalf
+    });
+  }
+  for (let i = 0; i < lonCount; i++) {
+    const angle = i / lonCount * Math.PI;
+    const nx = Math.cos(angle);
+    const nz = Math.sin(angle);
+    const p1 = projectVertex2({ x: nx * r, y: 0, z: nz * r }, opts);
+    const p2 = projectVertex2({ x: -nx * r, y: 0, z: -nz * r }, opts);
+    const pTop = projectVertex2({ x: 0, y: r, z: 0 }, opts);
+    const pBot = projectVertex2({ x: 0, y: -r, z: 0 }, opts);
+    const cc2D = { x: center.x, y: center.y };
+    const ax1 = Math.sqrt((p1.x - cc2D.x) ** 2 + (p1.y - cc2D.y) ** 2);
+    const ax2 = Math.sqrt((pTop.x - cc2D.x) ** 2 + (pTop.y - cc2D.y) ** 2);
+    const rot = Math.atan2(p1.y - cc2D.y, p1.x - cc2D.x);
+    const sliceNormalZ = rotate3D({ x: -nz, y: 0, z: nx }, matrix).z;
+    const frontHalf = sliceNormalZ > 0 ? [0, Math.PI] : [Math.PI, Math.PI * 2];
+    contours.push({
+      params: { cx: cc2D.x, cy: cc2D.y, rx: Math.max(ax1, ax2), ry: Math.min(ax1, ax2), rotation: rot },
+      frontHalf
+    });
+  }
+  return contours;
+}
+
+// src/forms/cone.ts
+function projectVertex3(v, opts) {
+  const rotated = rotate3D(v, opts.matrix);
+  const p = project(rotated, opts.projection, opts.focalLength);
+  return { x: opts.center.x + p.x * opts.scale, y: opts.center.y - p.y * opts.scale };
+}
+function renderCone(ctx, opts) {
+  const { sizeX, sizeY, sizeZ, edgeColor, showHidden, hiddenStyle, hiddenAlpha, matrix } = opts;
+  const halfH = sizeY / 2;
+  ctx.strokeStyle = edgeColor;
+  const savedAlpha = ctx.globalAlpha;
+  const apex = projectVertex3({ x: 0, y: halfH, z: 0 }, opts);
+  const baseCenter = projectVertex3({ x: 0, y: -halfH, z: 0 }, opts);
+  const basePx = projectVertex3({ x: sizeX * 0.5, y: -halfH, z: 0 }, opts);
+  const basePz = projectVertex3({ x: 0, y: -halfH, z: sizeZ * 0.5 }, opts);
+  const ax = Math.sqrt((basePx.x - baseCenter.x) ** 2 + (basePx.y - baseCenter.y) ** 2);
+  const az = Math.sqrt((basePz.x - baseCenter.x) ** 2 + (basePz.y - baseCenter.y) ** 2);
+  const angle = Math.atan2(basePx.y - baseCenter.y, basePx.x - baseCenter.x);
+  const baseEllipse = {
+    cx: baseCenter.x,
+    cy: baseCenter.y,
+    rx: Math.max(ax, az),
+    ry: Math.min(ax, az),
+    rotation: angle
+  };
+  const bottomNormalZ = rotate3D({ x: 0, y: -1, z: 0 }, matrix).z;
+  const baseVisible = bottomNormalZ > 0;
+  const baseFront = baseVisible ? [0, Math.PI] : [Math.PI, Math.PI * 2];
+  const hiddenDash = hiddenStyle === "dotted" ? [2, 3] : [6, 4];
+  const leftPoint = ellipsePointAt2(baseEllipse, Math.PI);
+  const rightPoint = ellipsePointAt2(baseEllipse, 0);
+  ctx.setLineDash([]);
+  ctx.globalAlpha = savedAlpha;
+  drawLine(ctx, apex.x, apex.y, leftPoint.x, leftPoint.y);
+  drawLine(ctx, apex.x, apex.y, rightPoint.x, rightPoint.y);
+  if (showHidden) {
+    drawEllipseWithHidden(ctx, baseEllipse, baseFront, hiddenAlpha, hiddenDash);
+  } else {
+    ctx.beginPath();
+    ctx.ellipse(
+      baseEllipse.cx,
+      baseEllipse.cy,
+      baseEllipse.rx,
+      baseEllipse.ry,
+      baseEllipse.rotation,
+      baseFront[0],
+      baseFront[1]
+    );
+    ctx.stroke();
+  }
+}
+function coneCrossContours(opts, count) {
+  const { sizeX, sizeY, sizeZ, matrix } = opts;
+  const halfH = sizeY / 2;
+  const contours = [];
+  for (let i = 1; i < count; i++) {
+    const t = i / count;
+    const y = -halfH + t * sizeY;
+    const taper = 1 - (y + halfH) / sizeY;
+    const rx = sizeX * 0.5 * taper;
+    const rz = sizeZ * 0.5 * taper;
+    if (rx < 1e-3 || rz < 1e-3) continue;
+    const cc = projectVertex3({ x: 0, y, z: 0 }, opts);
+    const px = projectVertex3({ x: rx, y, z: 0 }, opts);
+    const pz = projectVertex3({ x: 0, y, z: rz }, opts);
+    const ax = Math.sqrt((px.x - cc.x) ** 2 + (px.y - cc.y) ** 2);
+    const az = Math.sqrt((pz.x - cc.x) ** 2 + (pz.y - cc.y) ** 2);
+    const angle = Math.atan2(px.y - cc.y, px.x - cc.x);
+    const normalZ = rotate3D({ x: 0, y: 1, z: 0 }, matrix).z;
+    const frontHalf = normalZ > 0 ? [0, Math.PI] : [Math.PI, Math.PI * 2];
+    contours.push({
+      params: { cx: cc.x, cy: cc.y, rx: Math.max(ax, az), ry: Math.min(ax, az), rotation: angle },
+      frontHalf
+    });
+  }
+  return contours;
+}
+function ellipsePointAt2(params, angle) {
+  const cos = Math.cos(params.rotation);
+  const sin = Math.sin(params.rotation);
+  const px = params.rx * Math.cos(angle);
+  const py = params.ry * Math.sin(angle);
+  return {
+    x: params.cx + px * cos - py * sin,
+    y: params.cy + px * sin + py * cos
+  };
+}
+
+// src/forms/wedge.ts
+var WEDGE_VERTICES = [
+  { x: -0.5, y: -0.5, z: 0.5 },
+  // 0: front-left-bottom
+  { x: 0.5, y: -0.5, z: 0.5 },
+  // 1: front-right-bottom
+  { x: 0, y: 0.5, z: 0.5 },
+  // 2: front-top
+  { x: -0.5, y: -0.5, z: -0.5 },
+  // 3: back-left-bottom
+  { x: 0.5, y: -0.5, z: -0.5 },
+  // 4: back-right-bottom
+  { x: 0, y: 0.5, z: -0.5 }
+  // 5: back-top
+];
+var FACE_NORMALS2 = [
+  { x: 0, y: 0, z: 1 },
+  // 0: front (triangle 0,1,2)
+  { x: 0, y: 0, z: -1 },
+  // 1: back (triangle 3,4,5)
+  { x: 0, y: -1, z: 0 },
+  // 2: bottom (quad 0,1,4,3)
+  { x: -0.894, y: 0.447, z: 0 },
+  // 3: left slope (quad 0,2,5,3) normalized(-1, 0.5, 0)
+  { x: 0.894, y: 0.447, z: 0 }
+  // 4: right slope (quad 1,2,5,4) normalized(1, 0.5, 0)
+];
+var WEDGE_EDGES = [
+  // Front triangle
+  { a: 0, b: 1, faces: [0, 2] },
+  { a: 1, b: 2, faces: [0, 4] },
+  { a: 2, b: 0, faces: [0, 3] },
+  // Back triangle
+  { a: 3, b: 4, faces: [1, 2] },
+  { a: 4, b: 5, faces: [1, 4] },
+  { a: 5, b: 3, faces: [1, 3] },
+  // Connecting edges
+  { a: 0, b: 3, faces: [2, 3] },
+  { a: 1, b: 4, faces: [2, 4] },
+  { a: 2, b: 5, faces: [3, 4] }
+];
+function projectVertex4(v, opts) {
+  const scaled = { x: v.x * opts.sizeX, y: v.y * opts.sizeY, z: v.z * opts.sizeZ };
+  const rotated = rotate3D(scaled, opts.matrix);
+  const p = project(rotated, opts.projection, opts.focalLength);
+  return { x: opts.center.x + p.x * opts.scale, y: opts.center.y - p.y * opts.scale };
+}
+function renderWedge(ctx, opts) {
+  const { showHidden, hiddenStyle, hiddenAlpha, edgeColor, matrix } = opts;
+  const projected = WEDGE_VERTICES.map((v) => projectVertex4(v, opts));
+  const faceVisibility = FACE_NORMALS2.map((n) => transformedNormalZ(n, matrix) > 0);
+  ctx.strokeStyle = edgeColor;
+  const savedAlpha = ctx.globalAlpha;
+  if (showHidden) {
+    applyHiddenEdgeStyle(ctx, hiddenStyle, hiddenAlpha);
+    for (const edge of WEDGE_EDGES) {
+      if (!(faceVisibility[edge.faces[0]] || faceVisibility[edge.faces[1]])) {
+        const pa = projected[edge.a];
+        const pb = projected[edge.b];
+        drawLine(ctx, pa.x, pa.y, pb.x, pb.y);
+      }
+    }
+    resetEdgeStyle(ctx, savedAlpha);
+  }
+  ctx.setLineDash([]);
+  ctx.globalAlpha = savedAlpha;
+  for (const edge of WEDGE_EDGES) {
+    if (faceVisibility[edge.faces[0]] || faceVisibility[edge.faces[1]]) {
+      const pa = projected[edge.a];
+      const pb = projected[edge.b];
+      drawLine(ctx, pa.x, pa.y, pb.x, pb.y);
+    }
+  }
+}
+
+// src/forms/egg.ts
+function projectVertex5(v, opts) {
+  const rotated = rotate3D(v, opts.matrix);
+  const p = project(rotated, opts.projection, opts.focalLength);
+  return { x: opts.center.x + p.x * opts.scale, y: opts.center.y - p.y * opts.scale };
+}
+function eggRadius(t) {
+  const base = Math.sin(t * Math.PI);
+  const asymmetry = 1 - t * 0.3;
+  return base * asymmetry;
+}
+function renderEgg(ctx, opts) {
+  const { center, scale, sizeX, sizeY, sizeZ, matrix, projection, focalLength, edgeColor } = opts;
+  const segments = 48;
+  ctx.strokeStyle = edgeColor;
+  const outlinePoints = [];
+  for (let i = 0; i <= segments; i++) {
+    const angle = i / segments * Math.PI * 2;
+    const t = (Math.sin(angle) + 1) / 2;
+    const y = (t - 0.5) * sizeY;
+    const r = eggRadius(t);
+    const x = Math.cos(angle) * r * sizeX * 0.5;
+    const z = 0;
+    const rotated = rotate3D({ x, y, z }, matrix);
+    const p = project(rotated, projection, focalLength);
+    outlinePoints.push({ x: center.x + p.x * scale, y: center.y - p.y * scale });
+  }
+  const surfacePoints = [];
+  const ySteps = 32;
+  const aSteps = 24;
+  for (let yi = 0; yi <= ySteps; yi++) {
+    const t = yi / ySteps;
+    const y = (t - 0.5) * sizeY;
+    const r = eggRadius(t);
+    let leftmost = Infinity;
+    let rightmost = -Infinity;
+    let leftP = { x: 0, y: 0 };
+    let rightP = { x: 0, y: 0 };
+    for (let ai = 0; ai <= aSteps; ai++) {
+      const a = ai / aSteps * Math.PI * 2;
+      const x3d = Math.cos(a) * r * sizeX * 0.5;
+      const z3d = Math.sin(a) * r * sizeZ * 0.5;
+      const p3d = { x: x3d, y, z: z3d };
+      const rotated = rotate3D(p3d, matrix);
+      const p = project(rotated, projection, focalLength);
+      const sx = center.x + p.x * scale;
+      const sy = center.y - p.y * scale;
+      if (sx < leftmost) {
+        leftmost = sx;
+        leftP = { x: sx, y: sy };
+      }
+      if (sx > rightmost) {
+        rightmost = sx;
+        rightP = { x: sx, y: sy };
+      }
+    }
+    surfacePoints.push(leftP, rightP);
+  }
+  const leftPath = [];
+  const rightPath = [];
+  for (let i = 0; i < surfacePoints.length; i += 2) {
+    leftPath.push(surfacePoints[i]);
+    rightPath.push(surfacePoints[i + 1]);
+  }
+  ctx.beginPath();
+  if (leftPath.length > 1) {
+    ctx.moveTo(leftPath[0].x, leftPath[0].y);
+    for (let i = 1; i < leftPath.length; i++) {
+      ctx.lineTo(leftPath[i].x, leftPath[i].y);
+    }
+  }
+  for (let i = rightPath.length - 1; i >= 0; i--) {
+    ctx.lineTo(rightPath[i].x, rightPath[i].y);
+  }
+  ctx.closePath();
+  ctx.stroke();
+}
+function eggCrossContours(opts, count) {
+  const { center, scale, sizeX, sizeY, sizeZ, matrix, projection, focalLength } = opts;
+  const contours = [];
+  for (let i = 1; i < count; i++) {
+    const t = i / count;
+    const y = (t - 0.5) * sizeY;
+    const r = eggRadius(t);
+    const rx = r * sizeX * 0.5;
+    const rz = r * sizeZ * 0.5;
+    if (rx < 1e-3 || rz < 1e-3) continue;
+    const cc = projectVertex5({ x: 0, y, z: 0 }, opts);
+    const px = projectVertex5({ x: rx, y, z: 0 }, opts);
+    const pz = projectVertex5({ x: 0, y, z: rz }, opts);
+    const ax = Math.sqrt((px.x - cc.x) ** 2 + (px.y - cc.y) ** 2);
+    const az = Math.sqrt((pz.x - cc.x) ** 2 + (pz.y - cc.y) ** 2);
+    const angle = Math.atan2(px.y - cc.y, px.x - cc.x);
+    const normalZ = rotate3D({ x: 0, y: 1, z: 0 }, matrix).z;
+    const topVisible = normalZ > 0;
+    const isAboveCenter = t > 0.5;
+    const frontHalf = isAboveCenter === topVisible ? [0, Math.PI] : [Math.PI, Math.PI * 2];
+    contours.push({
+      params: { cx: cc.x, cy: cc.y, rx: Math.max(ax, az), ry: Math.min(ax, az), rotation: angle },
+      frontHalf
+    });
+  }
+  return contours;
+}
+
+// src/form-layer.ts
+var FORM_PROPERTIES = [
+  {
+    key: "formType",
+    label: "Form Type",
+    type: "select",
+    default: "box",
+    options: [
+      { value: "box", label: "Box" },
+      { value: "cylinder", label: "Cylinder" },
+      { value: "sphere", label: "Sphere" },
+      { value: "cone", label: "Cone" },
+      { value: "wedge", label: "Wedge" },
+      { value: "egg", label: "Egg / Ovoid" }
+    ],
+    group: "form"
+  },
+  {
+    key: "position",
+    label: "Position",
+    type: "point",
+    default: { x: 0.5, y: 0.5 },
+    group: "form"
+  },
+  {
+    key: "formSize",
+    label: "Size",
+    type: "number",
+    default: 0.25,
+    min: 0.05,
+    max: 0.6,
+    step: 0.01,
+    group: "form"
+  },
+  {
+    key: "sizeX",
+    label: "Width Scale",
+    type: "number",
+    default: 1,
+    min: 0.2,
+    max: 3,
+    step: 0.1,
+    group: "form"
+  },
+  {
+    key: "sizeY",
+    label: "Height Scale",
+    type: "number",
+    default: 1,
+    min: 0.2,
+    max: 3,
+    step: 0.1,
+    group: "form"
+  },
+  {
+    key: "sizeZ",
+    label: "Depth Scale",
+    type: "number",
+    default: 1,
+    min: 0.2,
+    max: 3,
+    step: 0.1,
+    group: "form"
+  },
+  {
+    key: "rotationX",
+    label: "Rotation X",
+    type: "number",
+    default: 15,
+    min: -90,
+    max: 90,
+    step: 5,
+    group: "rotation"
+  },
+  {
+    key: "rotationY",
+    label: "Rotation Y",
+    type: "number",
+    default: 30,
+    min: -180,
+    max: 180,
+    step: 5,
+    group: "rotation"
+  },
+  {
+    key: "rotationZ",
+    label: "Rotation Z",
+    type: "number",
+    default: 0,
+    min: -180,
+    max: 180,
+    step: 5,
+    group: "rotation"
+  },
+  {
+    key: "projection",
+    label: "Projection",
+    type: "select",
+    default: "orthographic",
+    options: [
+      { value: "orthographic", label: "Orthographic" },
+      { value: "weak-perspective", label: "Weak Perspective" }
+    ],
+    group: "projection"
+  },
+  {
+    key: "showCrossContours",
+    label: "Show Cross-Contours",
+    type: "boolean",
+    default: true,
+    group: "contours"
+  },
+  {
+    key: "crossContourCount",
+    label: "Cross-Contour Count",
+    type: "number",
+    default: 5,
+    min: 1,
+    max: 12,
+    step: 1,
+    group: "contours"
+  },
+  {
+    key: "showAxes",
+    label: "Show Axes",
+    type: "boolean",
+    default: true,
+    group: "display"
+  },
+  {
+    key: "axisLength",
+    label: "Axis Length",
+    type: "number",
+    default: 1.2,
+    min: 0.5,
+    max: 2,
+    step: 0.1,
+    group: "display"
+  },
+  {
+    key: "showHiddenEdges",
+    label: "Show Hidden Edges",
+    type: "boolean",
+    default: true,
+    group: "display"
+  },
+  {
+    key: "hiddenEdgeStyle",
+    label: "Hidden Edge Style",
+    type: "select",
+    default: "dashed",
+    options: [
+      { value: "dashed", label: "Dashed" },
+      { value: "dotted", label: "Dotted" },
+      { value: "faint", label: "Faint" },
+      { value: "hidden", label: "Hidden" }
+    ],
+    group: "display"
+  },
+  {
+    key: "hiddenEdgeAlpha",
+    label: "Hidden Edge Alpha",
+    type: "number",
+    default: 0.3,
+    min: 0,
+    max: 0.8,
+    step: 0.05,
+    group: "display"
+  },
+  {
+    key: "edgeColor",
+    label: "Edge Color",
+    type: "color",
+    default: "rgba(0,200,255,0.7)",
+    group: "style"
+  },
+  {
+    key: "contourColor",
+    label: "Contour Color",
+    type: "color",
+    default: "rgba(100,255,100,0.5)",
+    group: "style"
+  },
+  {
+    key: "axisColors",
+    label: "Axis Colors (X,Y,Z)",
+    type: "string",
+    default: "red,green,blue",
+    group: "style"
+  },
+  ...COMMON_GUIDE_PROPERTIES
+];
+var formLayerType = {
+  typeId: "construction:form",
+  displayName: "Construction Form",
+  icon: "cube",
+  category: "guide",
+  properties: FORM_PROPERTIES,
+  propertyEditorId: "construction:form-editor",
+  createDefault() {
+    const props = {};
+    for (const schema of FORM_PROPERTIES) {
+      props[schema.key] = schema.default;
+    }
+    return props;
+  },
+  render(properties, ctx, bounds) {
+    const formType = properties.formType ?? "box";
+    const pos = properties.position;
+    const center = toPixel(pos ?? { x: 0.5, y: 0.5 }, bounds);
+    const formSize = properties.formSize ?? 0.25;
+    const sizeX = properties.sizeX ?? 1;
+    const sizeY = properties.sizeY ?? 1;
+    const sizeZ = properties.sizeZ ?? 1;
+    const rxDeg = properties.rotationX ?? 15;
+    const ryDeg = properties.rotationY ?? 30;
+    const rzDeg = properties.rotationZ ?? 0;
+    const proj = properties.projection ?? "orthographic";
+    const showContours = properties.showCrossContours ?? true;
+    const contourCount = properties.crossContourCount ?? 5;
+    const showAxes = properties.showAxes ?? true;
+    const axisLen = properties.axisLength ?? 1.2;
+    const showHidden = properties.showHiddenEdges ?? true;
+    const hiddenStyle = properties.hiddenEdgeStyle ?? "dashed";
+    const hiddenAlpha = properties.hiddenEdgeAlpha ?? 0.3;
+    const edgeColor = properties.edgeColor ?? "rgba(0,200,255,0.7)";
+    const contourColor = properties.contourColor ?? "rgba(100,255,100,0.5)";
+    const axisColorsCSV = properties.axisColors ?? "red,green,blue";
+    const scale = Math.min(bounds.width, bounds.height) * formSize;
+    const matrix = rotationMatrix(rxDeg, ryDeg, rzDeg);
+    const focalLength = 5;
+    ctx.save();
+    const baseOpts = {
+      center,
+      scale,
+      sizeX,
+      sizeY,
+      sizeZ,
+      matrix,
+      projection: proj,
+      focalLength,
+      showHidden,
+      hiddenStyle,
+      hiddenAlpha,
+      edgeColor
+    };
+    switch (formType) {
+      case "box":
+        renderBox(ctx, baseOpts);
+        break;
+      case "cylinder":
+        renderCylinder(ctx, baseOpts);
+        break;
+      case "sphere":
+        renderSphere(ctx, { ...baseOpts, radius: 0.5 });
+        break;
+      case "cone":
+        renderCone(ctx, baseOpts);
+        break;
+      case "wedge":
+        renderWedge(ctx, baseOpts);
+        break;
+      case "egg":
+        renderEgg(ctx, baseOpts);
+        break;
+    }
+    if (showContours) {
+      ctx.strokeStyle = contourColor;
+      ctx.lineWidth = 0.75;
+      const hiddenDash = hiddenStyle === "dotted" ? [2, 3] : [6, 4];
+      switch (formType) {
+        case "box": {
+          const contours = boxCrossContours(baseOpts, contourCount);
+          for (const line of contours.front) {
+            drawPolyline(ctx, line);
+          }
+          if (showHidden) {
+            ctx.globalAlpha = hiddenAlpha;
+            ctx.setLineDash(hiddenDash);
+            for (const line of contours.hidden) {
+              drawPolyline(ctx, line);
+            }
+            ctx.globalAlpha = 1;
+            ctx.setLineDash([]);
+          }
+          break;
+        }
+        case "cylinder": {
+          const contours = cylinderCrossContours(baseOpts, contourCount + 1);
+          for (const c of contours) {
+            drawEllipseWithHidden(ctx, c.params, c.frontHalf, hiddenAlpha, hiddenDash);
+          }
+          break;
+        }
+        case "sphere": {
+          const latCount = Math.ceil(contourCount / 2);
+          const lonCount = Math.floor(contourCount / 2);
+          const contours = sphereCrossContours({ ...baseOpts, radius: 0.5 }, latCount + 1, lonCount);
+          for (const c of contours) {
+            drawEllipseWithHidden(ctx, c.params, c.frontHalf, hiddenAlpha, hiddenDash);
+          }
+          break;
+        }
+        case "cone": {
+          const contours = coneCrossContours(baseOpts, contourCount + 1);
+          for (const c of contours) {
+            drawEllipseWithHidden(ctx, c.params, c.frontHalf, hiddenAlpha, hiddenDash);
+          }
+          break;
+        }
+        case "egg": {
+          const contours = eggCrossContours(baseOpts, contourCount + 1);
+          for (const c of contours) {
+            drawEllipseWithHidden(ctx, c.params, c.frontHalf, hiddenAlpha, hiddenDash);
+          }
+          break;
+        }
+      }
+    }
+    if (showAxes) {
+      const axisColors = parseCSVColors(axisColorsCSV, 3);
+      const axisScale = scale * axisLen;
+      const axes = [
+        { dir: { x: 1, y: 0, z: 0 }, color: axisColors[0] },
+        { dir: { x: 0, y: 1, z: 0 }, color: axisColors[1] },
+        { dir: { x: 0, y: 0, z: 1 }, color: axisColors[2] }
+      ];
+      for (const axis of axes) {
+        const rotated = rotate3D(axis.dir, matrix);
+        const p = project(rotated, proj, focalLength);
+        const endX = center.x + p.x * axisScale;
+        const endY = center.y - p.y * axisScale;
+        ctx.strokeStyle = axis.color;
+        ctx.lineWidth = 1.5;
+        ctx.setLineDash([]);
+        drawLine(ctx, center.x, center.y, endX, endY);
+      }
+    }
+    ctx.restore();
+  },
+  validate(properties) {
+    const errors = [];
+    const formType = properties.formType;
+    if (!["box", "cylinder", "sphere", "cone", "wedge", "egg"].includes(formType)) {
+      errors.push({ property: "formType", message: "Invalid form type" });
+    }
+    const rx = properties.rotationX;
+    if (typeof rx === "number" && (rx < -90 || rx > 90)) {
+      errors.push({ property: "rotationX", message: "Must be -90 to 90" });
+    }
+    return errors.length > 0 ? errors : null;
+  }
+};
+
+// src/cross-contour-layer.ts
+var CROSS_CONTOUR_PROPERTIES = [
+  { key: "outline", label: "Outline Points (JSON)", type: "string", default: "[]", group: "shape" },
+  { key: "axis", label: "Axis Points (JSON)", type: "string", default: "[]", group: "shape" },
+  { key: "contourCount", label: "Contour Count", type: "number", default: 8, min: 2, max: 20, step: 1, group: "contours" },
+  { key: "curvature", label: "Curvature", type: "number", default: 0.5, min: 0, max: 1, step: 0.05, group: "contours" },
+  { key: "curvatureVariation", label: "Curvature Variation (JSON)", type: "string", default: "[]", group: "contours" },
+  {
+    key: "contourStyle",
+    label: "Contour Style",
+    type: "select",
+    default: "elliptical",
+    options: [
+      { value: "elliptical", label: "Elliptical" },
+      { value: "angular", label: "Angular" },
+      { value: "organic", label: "Organic" }
+    ],
+    group: "contours"
+  },
+  { key: "showAxis", label: "Show Axis", type: "boolean", default: true, group: "display" },
+  { key: "showOutline", label: "Show Outline", type: "boolean", default: true, group: "display" },
+  {
+    key: "wrapDirection",
+    label: "Wrap Direction",
+    type: "select",
+    default: "perpendicular",
+    options: [{ value: "perpendicular", label: "Perpendicular" }, { value: "custom", label: "Custom" }],
+    group: "contours"
+  },
+  {
+    key: "contourSpacing",
+    label: "Contour Spacing",
+    type: "select",
+    default: "even",
+    options: [{ value: "even", label: "Even" }, { value: "perspective", label: "Perspective" }],
+    group: "contours"
+  },
+  ...COMMON_GUIDE_PROPERTIES
+];
+var crossContourLayerType = {
+  typeId: "construction:cross-contour",
+  displayName: "Cross-Contour Lines",
+  icon: "waves",
+  category: "guide",
+  properties: CROSS_CONTOUR_PROPERTIES,
+  propertyEditorId: "construction:cross-contour-editor",
+  createDefault() {
+    const props = {};
+    for (const schema of CROSS_CONTOUR_PROPERTIES) {
+      props[schema.key] = schema.default;
+    }
+    return props;
+  },
+  render(properties, ctx, bounds) {
+    const outlineNorm = parseJSON(properties.outline ?? "[]", []);
+    const axisNorm = parseJSON(properties.axis ?? "[]", []);
+    if (axisNorm.length < 2) return;
+    const contourCount = properties.contourCount ?? 8;
+    const curvature = properties.curvature ?? 0.5;
+    const curvatureVar = parseJSON(properties.curvatureVariation ?? "[]", []);
+    const contourStyle = properties.contourStyle ?? "elliptical";
+    const showAxis = properties.showAxis ?? true;
+    const showOutline = properties.showOutline ?? true;
+    const spacing = properties.contourSpacing ?? "even";
+    const color = properties.guideColor ?? "rgba(0,200,255,0.5)";
+    const lineWidth = properties.lineWidth ?? 1;
+    const toPixelPt = (p) => ({
+      x: bounds.x + p.x * bounds.width,
+      y: bounds.y + p.y * bounds.height
+    });
+    const outline = outlineNorm.map(toPixelPt);
+    const axis = axisNorm.map(toPixelPt);
+    ctx.save();
+    if (showOutline && outline.length >= 2) {
+      ctx.strokeStyle = color;
+      ctx.lineWidth = lineWidth * 0.7;
+      ctx.globalAlpha = 0.5;
+      ctx.setLineDash([4, 3]);
+      drawPolyline(ctx, outline, true);
+      ctx.globalAlpha = 1;
+    }
+    if (showAxis && axis.length >= 2) {
+      ctx.strokeStyle = color;
+      ctx.lineWidth = lineWidth * 0.5;
+      ctx.setLineDash([3, 5]);
+      ctx.globalAlpha = 0.4;
+      drawPolyline(ctx, axis);
+      ctx.globalAlpha = 1;
+    }
+    const axisPoints = interpolatePolyline(axis, 200);
+    setupGuideStyle(ctx, color, lineWidth, "");
+    ctx.setLineDash([]);
+    for (let i = 0; i < contourCount; i++) {
+      let t;
+      if (spacing === "perspective") {
+        const raw = (i + 1) / (contourCount + 1);
+        t = 0.5 + (raw - 0.5) * Math.sqrt(Math.abs(raw - 0.5) * 2) * Math.sign(raw - 0.5);
+      } else {
+        t = (i + 1) / (contourCount + 1);
+      }
+      const axisIdx = Math.floor(t * (axisPoints.length - 1));
+      const axisPoint = axisPoints[Math.min(axisIdx, axisPoints.length - 1)];
+      const prevIdx = Math.max(0, axisIdx - 1);
+      const nextIdx = Math.min(axisPoints.length - 1, axisIdx + 1);
+      const tangent = {
+        x: axisPoints[nextIdx].x - axisPoints[prevIdx].x,
+        y: axisPoints[nextIdx].y - axisPoints[prevIdx].y
+      };
+      const tangentLen = Math.sqrt(tangent.x ** 2 + tangent.y ** 2);
+      if (tangentLen < 1e-3) continue;
+      const perpX = -tangent.y / tangentLen;
+      const perpY = tangent.x / tangentLen;
+      const leftEdge = findOutlineIntersection(axisPoint, { x: perpX, y: perpY }, outline);
+      const rightEdge = findOutlineIntersection(axisPoint, { x: -perpX, y: -perpY }, outline);
+      if (!leftEdge || !rightEdge) continue;
+      const curv = curvatureVar[i] ?? curvature;
+      const contourLine = generateContourLine(leftEdge, rightEdge, axisPoint, curv, contourStyle);
+      drawPolyline(ctx, contourLine);
+    }
+    ctx.restore();
+  },
+  validate(properties) {
+    const errors = [];
+    const count = properties.contourCount;
+    if (typeof count === "number" && (count < 2 || count > 20)) {
+      errors.push({ property: "contourCount", message: "Must be 2-20" });
+    }
+    return errors.length > 0 ? errors : null;
+  }
+};
+function polylineLength(points) {
+  let len = 0;
+  for (let i = 1; i < points.length; i++) len += dist2(points[i - 1], points[i]);
+  return len;
+}
+function interpolatePolyline(points, targetCount) {
+  if (points.length < 2) return points;
+  const totalLen = polylineLength(points);
+  if (totalLen < 1e-3) return points;
+  const result = [];
+  const step = totalLen / (targetCount - 1);
+  let segIdx = 0;
+  let segStart = 0;
+  for (let i = 0; i < targetCount; i++) {
+    const target = i * step;
+    while (segIdx < points.length - 2) {
+      const segLen2 = dist2(points[segIdx], points[segIdx + 1]);
+      if (segStart + segLen2 >= target) break;
+      segStart += segLen2;
+      segIdx++;
+    }
+    const segLen = dist2(points[segIdx], points[segIdx + 1]);
+    const t = segLen > 0 ? (target - segStart) / segLen : 0;
+    result.push(lerp2(points[segIdx], points[segIdx + 1], Math.min(1, Math.max(0, t))));
+  }
+  return result;
+}
+function findOutlineIntersection(origin, direction, outline) {
+  let bestT = Infinity;
+  let bestPoint = null;
+  for (let i = 0; i < outline.length; i++) {
+    const a = outline[i];
+    const b = outline[(i + 1) % outline.length];
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const denom = direction.x * dy - direction.y * dx;
+    if (Math.abs(denom) < 1e-10) continue;
+    const t = ((a.x - origin.x) * dy - (a.y - origin.y) * dx) / denom;
+    const u = ((a.x - origin.x) * direction.y - (a.y - origin.y) * direction.x) / denom;
+    if (t > 0 && u >= 0 && u <= 1 && t < bestT) {
+      bestT = t;
+      bestPoint = { x: origin.x + direction.x * t, y: origin.y + direction.y * t };
+    }
+  }
+  return bestPoint;
+}
+function generateContourLine(left, right, axisPoint, curvature, style) {
+  const segments = 20;
+  const points = [];
+  const lrDx = right.x - left.x, lrDy = right.y - left.y;
+  const lrLen = Math.sqrt(lrDx * lrDx + lrDy * lrDy);
+  if (lrLen < 1e-3) return [left, right];
+  const perpX = -lrDy / lrLen, perpY = lrDx / lrLen;
+  const toAxisX = axisPoint.x - (left.x + right.x) / 2;
+  const toAxisY = axisPoint.y - (left.y + right.y) / 2;
+  const sign = perpX * toAxisX + perpY * toAxisY > 0 ? 1 : -1;
+  for (let i = 0; i <= segments; i++) {
+    const t = i / segments;
+    const baseX = left.x + (right.x - left.x) * t;
+    const baseY = left.y + (right.y - left.y) * t;
+    let offset;
+    if (style === "angular") {
+      offset = curvature * (1 - Math.abs(t - 0.5) * 2) * lrLen * 0.3 * sign;
+    } else {
+      offset = curvature * Math.sin(t * Math.PI) * lrLen * 0.3 * sign;
+    }
+    points.push({ x: baseX + perpX * offset, y: baseY + perpY * offset });
+  }
+  return points;
+}
+
+// src/math/shadow.ts
+var DEG2RAD3 = Math.PI / 180;
+function lightDirection(light) {
+  const az = light.azimuth * DEG2RAD3;
+  const el = light.elevation * DEG2RAD3;
+  const cosEl = Math.cos(el);
+  return normalize3({
+    x: -Math.cos(az) * cosEl,
+    y: -Math.sin(el),
+    z: -Math.sin(az) * cosEl
+  });
+}
+function lightDirection2D(light) {
+  const az = light.azimuth * DEG2RAD3;
+  return { x: Math.cos(az), y: Math.sin(az) };
+}
+function sphereTerminator(center, radius, light, matrix) {
+  const ld = lightDirection(light);
+  const rotatedLD = rotate3D(ld, matrix);
+  const ldScreen = { x: rotatedLD.x, y: -rotatedLD.y };
+  const perpAngle = Math.atan2(ldScreen.y, ldScreen.x) + Math.PI / 2;
+  const viewAngle = Math.acos(Math.min(1, Math.abs(rotatedLD.z)));
+  const minorRadius = radius * Math.sin(viewAngle);
+  return {
+    terminatorEllipse: {
+      cx: center.x,
+      cy: center.y,
+      rx: radius,
+      ry: minorRadius,
+      rotation: perpAngle
+    },
+    lightSide: { x: -ldScreen.x, y: -ldScreen.y }
+  };
+}
+function castShadow(center, radius, light, groundY) {
+  const ld = lightDirection(light);
+  const ld2d = lightDirection2D(light);
+  const shadowLength = radius * (1 / Math.tan(light.elevation * DEG2RAD3));
+  const shadowDirX = -ld2d.x;
+  const shadowDirY = 0;
+  const points = [];
+  const segments = 24;
+  for (let i = 0; i <= segments; i++) {
+    const angle = i / segments * Math.PI * 2;
+    const bx = Math.cos(angle) * radius;
+    const by = Math.sin(angle) * radius * 0.3;
+    const sx = center.x + bx + shadowDirX * shadowLength * 0.5;
+    const sy = groundY + by;
+    points.push({ x: sx, y: sy });
+  }
+  return points;
+}
+function sphereValueZones(center, radius, light, matrix, grouping) {
+  const zones = [];
+  const ld = lightDirection(light);
+  const rotatedLD = rotate3D(ld, matrix);
+  const ldScreen = { x: -rotatedLD.x, y: rotatedLD.y };
+  const terminatorAngle = Math.atan2(ldScreen.y, ldScreen.x);
+  const segments = 32;
+  if (grouping === "two-value") {
+    zones.push({
+      type: "light",
+      path: generateArcPath(center, radius, terminatorAngle - Math.PI / 2, terminatorAngle + Math.PI / 2, segments),
+      value: 0.8,
+      label: "Light"
+    });
+    zones.push({
+      type: "core-shadow",
+      path: generateArcPath(center, radius, terminatorAngle + Math.PI / 2, terminatorAngle + Math.PI * 1.5, segments),
+      value: 0.2,
+      label: "Shadow"
+    });
+  } else if (grouping === "three-value") {
+    zones.push({
+      type: "light",
+      path: generateArcPath(center, radius, terminatorAngle - Math.PI / 2, terminatorAngle, segments),
+      value: 0.85,
+      label: "Light"
+    });
+    zones.push({
+      type: "halftone",
+      path: generateArcPath(center, radius, terminatorAngle, terminatorAngle + Math.PI / 3, segments),
+      value: 0.5,
+      label: "Halftone"
+    });
+    zones.push({
+      type: "core-shadow",
+      path: generateArcPath(center, radius, terminatorAngle + Math.PI / 3, terminatorAngle + Math.PI * 1.5, segments),
+      value: 0.15,
+      label: "Shadow"
+    });
+  } else {
+    const lightEnd = terminatorAngle - Math.PI / 6;
+    const highlightEnd = terminatorAngle - Math.PI / 3;
+    zones.push({
+      type: "highlight",
+      path: generateArcPath(center, radius, terminatorAngle - Math.PI / 2, highlightEnd, segments),
+      value: 0.95,
+      label: "Highlight"
+    });
+    zones.push({
+      type: "light",
+      path: generateArcPath(center, radius, highlightEnd, lightEnd, segments),
+      value: 0.8,
+      label: "Light"
+    });
+    zones.push({
+      type: "halftone",
+      path: generateArcPath(center, radius, lightEnd, terminatorAngle + Math.PI / 6, segments),
+      value: 0.5,
+      label: "Halftone"
+    });
+    zones.push({
+      type: "core-shadow",
+      path: generateArcPath(center, radius, terminatorAngle + Math.PI / 6, terminatorAngle + Math.PI * 0.6, segments),
+      value: 0.1,
+      label: "Core Shadow"
+    });
+    zones.push({
+      type: "reflected-light",
+      path: generateArcPath(center, radius, terminatorAngle + Math.PI * 0.6, terminatorAngle + Math.PI * 1.5, segments),
+      value: 0.3,
+      label: "Reflected Light"
+    });
+  }
+  return zones;
+}
+function generateArcPath(center, radius, startAngle, endAngle, segments) {
+  const points = [{ x: center.x, y: center.y }];
+  for (let i = 0; i <= segments; i++) {
+    const t = i / segments;
+    const angle = startAngle + (endAngle - startAngle) * t;
+    points.push({
+      x: center.x + Math.cos(angle) * radius,
+      y: center.y + Math.sin(angle) * radius
+    });
+  }
+  return points;
+}
+
+// src/value-shapes-layer.ts
+var VALUE_SHAPES_PROPERTIES = [
+  {
+    key: "formData",
+    label: "Forms (JSON)",
+    type: "string",
+    default: "[]",
+    group: "forms"
+  },
+  {
+    key: "lightAzimuth",
+    label: "Light Azimuth",
+    type: "number",
+    default: 315,
+    min: 0,
+    max: 360,
+    step: 15,
+    group: "light"
+  },
+  {
+    key: "lightElevation",
+    label: "Light Elevation",
+    type: "number",
+    default: 45,
+    min: 10,
+    max: 80,
+    step: 5,
+    group: "light"
+  },
+  {
+    key: "lightIntensity",
+    label: "Light Intensity",
+    type: "number",
+    default: 0.8,
+    min: 0.1,
+    max: 1,
+    step: 0.05,
+    group: "light"
+  },
+  {
+    key: "showLightIndicator",
+    label: "Show Light Indicator",
+    type: "boolean",
+    default: true,
+    group: "display"
+  },
+  {
+    key: "valueGrouping",
+    label: "Value Grouping",
+    type: "select",
+    default: "three-value",
+    options: [
+      { value: "two-value", label: "2-Value (Light/Shadow)" },
+      { value: "three-value", label: "3-Value (Light/Half/Shadow)" },
+      { value: "five-value", label: "5-Value (Full Anatomy)" }
+    ],
+    group: "display"
+  },
+  {
+    key: "shadowColor",
+    label: "Shadow Color",
+    type: "color",
+    default: "rgba(0,0,0,0.3)",
+    group: "style"
+  },
+  {
+    key: "lightColor",
+    label: "Light Color",
+    type: "color",
+    default: "rgba(255,255,200,0.15)",
+    group: "style"
+  },
+  {
+    key: "halftoneColor",
+    label: "Halftone Color",
+    type: "color",
+    default: "rgba(0,0,0,0.12)",
+    group: "style"
+  },
+  {
+    key: "highlightColor",
+    label: "Highlight Color",
+    type: "color",
+    default: "rgba(255,255,255,0.25)",
+    group: "style"
+  },
+  {
+    key: "reflectedLightColor",
+    label: "Reflected Light Color",
+    type: "color",
+    default: "rgba(100,100,120,0.15)",
+    group: "style"
+  },
+  {
+    key: "showTerminator",
+    label: "Show Terminator",
+    type: "boolean",
+    default: true,
+    group: "display"
+  },
+  {
+    key: "terminatorWidth",
+    label: "Terminator Width",
+    type: "number",
+    default: 2,
+    min: 1,
+    max: 5,
+    step: 0.5,
+    group: "display"
+  },
+  {
+    key: "showCastShadow",
+    label: "Show Cast Shadow",
+    type: "boolean",
+    default: true,
+    group: "display"
+  },
+  {
+    key: "showOcclusionShadow",
+    label: "Show Occlusion Shadow",
+    type: "boolean",
+    default: true,
+    group: "display"
+  },
+  {
+    key: "showZoneLabels",
+    label: "Show Zone Labels",
+    type: "boolean",
+    default: false,
+    group: "display"
+  },
+  {
+    key: "groundPlaneY",
+    label: "Ground Plane Y",
+    type: "number",
+    default: 0.8,
+    min: 0,
+    max: 1,
+    step: 0.05,
+    group: "light"
+  },
+  ...COMMON_GUIDE_PROPERTIES
+];
+var valueShapesLayerType = {
+  typeId: "construction:value-shapes",
+  displayName: "Value Shapes Study",
+  icon: "sun",
+  category: "guide",
+  properties: VALUE_SHAPES_PROPERTIES,
+  propertyEditorId: "construction:value-shapes-editor",
+  createDefault() {
+    const props = {};
+    for (const schema of VALUE_SHAPES_PROPERTIES) {
+      props[schema.key] = schema.default;
+    }
+    return props;
+  },
+  render(properties, ctx, bounds) {
+    const formDataJSON = properties.formData ?? "[]";
+    const forms = parseJSON(formDataJSON, []);
+    const lightAzimuth = properties.lightAzimuth ?? 315;
+    const lightElevation = properties.lightElevation ?? 45;
+    const lightIntensity = properties.lightIntensity ?? 0.8;
+    const showIndicator = properties.showLightIndicator ?? true;
+    const grouping = properties.valueGrouping ?? "three-value";
+    const shadowColor = properties.shadowColor ?? "rgba(0,0,0,0.3)";
+    const lightColor = properties.lightColor ?? "rgba(255,255,200,0.15)";
+    const halftoneColor = properties.halftoneColor ?? "rgba(0,0,0,0.12)";
+    const highlightColor = properties.highlightColor ?? "rgba(255,255,255,0.25)";
+    const reflectedLightColor = properties.reflectedLightColor ?? "rgba(100,100,120,0.15)";
+    const showTerminator = properties.showTerminator ?? true;
+    const terminatorWidth = properties.terminatorWidth ?? 2;
+    const showCastShadow = properties.showCastShadow ?? true;
+    const showOcclusion = properties.showOcclusionShadow ?? true;
+    const showLabels = properties.showZoneLabels ?? false;
+    const groundPlaneY = properties.groundPlaneY ?? 0.8;
+    const light = {
+      azimuth: lightAzimuth,
+      elevation: lightElevation,
+      intensity: lightIntensity
+    };
+    ctx.save();
+    const effectiveForms = forms.length > 0 ? forms : [{ type: "sphere", position: { x: 0, y: 0, z: 0 }, size: { x: 1, y: 1, z: 1 }, rotation: { x: 0, y: 0, z: 0 } }];
+    for (const form of effectiveForms) {
+      const centerNorm = {
+        x: 0.5 + form.position.x * 0.3,
+        y: 0.5 - form.position.y * 0.3
+      };
+      const center = toPixel(centerNorm, bounds);
+      const radius = Math.min(bounds.width, bounds.height) * 0.15 * form.size.x;
+      const matrix = rotationMatrix(form.rotation.x, form.rotation.y, form.rotation.z);
+      const groundPx = bounds.y + groundPlaneY * bounds.height;
+      const zones = sphereValueZones(center, radius, light, matrix, grouping);
+      const colorMap = {
+        "highlight": highlightColor,
+        "light": lightColor,
+        "halftone": halftoneColor,
+        "core-shadow": shadowColor,
+        "reflected-light": reflectedLightColor,
+        "cast-shadow": shadowColor,
+        "occlusion-shadow": shadowColor
+      };
+      for (const zone of zones) {
+        fillPolyline(ctx, zone.path, colorMap[zone.type] ?? shadowColor);
+      }
+      if (showTerminator) {
+        const term = sphereTerminator(center, radius, light, matrix);
+        ctx.strokeStyle = "rgba(255,100,0,0.6)";
+        ctx.lineWidth = terminatorWidth;
+        ctx.setLineDash([]);
+        drawEllipse(
+          ctx,
+          term.terminatorEllipse.cx,
+          term.terminatorEllipse.cy,
+          term.terminatorEllipse.rx,
+          term.terminatorEllipse.ry,
+          term.terminatorEllipse.rotation
+        );
+      }
+      if (showCastShadow) {
+        const shadow = castShadow(center, radius, light, groundPx);
+        fillPolyline(ctx, shadow, "rgba(0,0,0,0.15)");
+      }
+      if (showOcclusion) {
+        const occRadius = radius * 0.15;
+        ctx.beginPath();
+        ctx.ellipse(center.x, center.y + radius, occRadius * 3, occRadius, 0, 0, Math.PI * 2);
+        ctx.fillStyle = "rgba(0,0,0,0.25)";
+        ctx.fill();
+      }
+      if (showLabels) {
+        for (const zone of zones) {
+          if (zone.path.length > 2) {
+            let cx = 0, cy = 0;
+            for (const p of zone.path) {
+              cx += p.x;
+              cy += p.y;
+            }
+            cx /= zone.path.length;
+            cy /= zone.path.length;
+            drawLabel(ctx, zone.label, cx, cy, "rgba(255,255,255,0.8)", 9);
+          }
+        }
+      }
+      ctx.strokeStyle = "rgba(0,200,255,0.5)";
+      ctx.lineWidth = 1;
+      ctx.setLineDash([6, 4]);
+      ctx.beginPath();
+      ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
+      ctx.stroke();
+    }
+    if (showIndicator) {
+      const ld2d = lightDirection2D(light);
+      const indX = bounds.x + bounds.width - 30;
+      const indY = bounds.y + 30;
+      const indLen = 15;
+      ctx.strokeStyle = "rgba(255,220,50,0.8)";
+      ctx.lineWidth = 2;
+      ctx.setLineDash([]);
+      drawLine(ctx, indX, indY, indX + ld2d.x * indLen, indY + ld2d.y * indLen);
+      ctx.beginPath();
+      ctx.arc(indX, indY, 6, 0, Math.PI * 2);
+      ctx.fillStyle = "rgba(255,220,50,0.6)";
+      ctx.fill();
+      ctx.stroke();
+    }
+    ctx.restore();
+  },
+  validate(properties) {
+    const errors = [];
+    const el = properties.lightElevation;
+    if (typeof el === "number" && (el < 10 || el > 80)) {
+      errors.push({ property: "lightElevation", message: "Must be 10-80" });
+    }
+    return errors.length > 0 ? errors : null;
+  }
+};
+
+// src/math/envelope.ts
+function convexHull(points) {
+  if (points.length < 3) return [...points];
+  const sorted = [...points].sort((a, b) => a.x - b.x || a.y - b.y);
+  const lower = [];
+  for (const p of sorted) {
+    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+      lower.pop();
+    }
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = sorted.length - 1; i >= 0; i--) {
+    const p = sorted[i];
+    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+      upper.pop();
+    }
+    upper.push(p);
+  }
+  lower.pop();
+  upper.pop();
+  return lower.concat(upper);
+}
+function cross(o, a, b) {
+  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+function computeEnvelope(points, style) {
+  if (points.length < 3) return [...points];
+  if (style === "fitted") return [...points];
+  const hull = convexHull(points);
+  if (style === "loose") {
+    const cx = hull.reduce((s, p) => s + p.x, 0) / hull.length;
+    const cy = hull.reduce((s, p) => s + p.y, 0) / hull.length;
+    const expand = 0.05;
+    return hull.map((p) => ({
+      x: p.x + (p.x - cx) * expand,
+      y: p.y + (p.y - cy) * expand
+    }));
+  }
+  return hull;
+}
+function envelopeAngles(vertices) {
+  const n = vertices.length;
+  if (n < 3) return [];
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    const prev = vertices[(i - 1 + n) % n];
+    const curr = vertices[i];
+    const next = vertices[(i + 1) % n];
+    const dx1 = prev.x - curr.x, dy1 = prev.y - curr.y;
+    const dx2 = next.x - curr.x, dy2 = next.y - curr.y;
+    const dot = dx1 * dx2 + dy1 * dy2;
+    const len1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+    const len2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+    if (len1 < 1e-10 || len2 < 1e-10) {
+      result.push({ vertex: curr, angle: 180 });
+      continue;
+    }
+    const cosAngle = Math.max(-1, Math.min(1, dot / (len1 * len2)));
+    const angle = Math.acos(cosAngle) * (180 / Math.PI);
+    result.push({ vertex: curr, angle });
+  }
+  return result;
+}
+function plumbLine(referencePoint, bounds) {
+  return [
+    { x: referencePoint.x, y: bounds.y },
+    { x: referencePoint.x, y: bounds.y + bounds.height }
+  ];
+}
+function levelLine(referencePoint, bounds) {
+  return [
+    { x: bounds.x, y: referencePoint.y },
+    { x: bounds.x + bounds.width, y: referencePoint.y }
+  ];
+}
+function comparativeMeasure(segment1, segment2) {
+  const len1 = dist2(segment1[0], segment1[1]);
+  const len2 = dist2(segment2[0], segment2[1]);
+  if (len2 < 1e-10) return { ratio: Infinity, label: "\u221E" };
+  const ratio = len1 / len2;
+  return { ratio, label: `1 : ${ratio.toFixed(2)}` };
+}
+
+// src/envelope-layer.ts
+var ENVELOPE_PROPERTIES = [
+  { key: "envelopePath", label: "Envelope Points (JSON)", type: "string", default: "[]", group: "envelope" },
+  {
+    key: "envelopeStyle",
+    label: "Envelope Style",
+    type: "select",
+    default: "tight",
+    options: [
+      { value: "tight", label: "Tight (Convex Hull)" },
+      { value: "loose", label: "Loose (Expanded)" },
+      { value: "fitted", label: "Fitted (As Given)" }
+    ],
+    group: "envelope"
+  },
+  { key: "showAngles", label: "Show Angles", type: "boolean", default: true, group: "display" },
+  { key: "angleThreshold", label: "Angle Threshold", type: "number", default: 10, min: 5, max: 45, step: 5, group: "display" },
+  { key: "showPlumbLine", label: "Show Plumb Line", type: "boolean", default: true, group: "display" },
+  { key: "plumbLinePoint", label: "Plumb Line Point", type: "point", default: { x: 0.5, y: 0 }, group: "display" },
+  { key: "showLevelLines", label: "Show Level Lines", type: "boolean", default: false, group: "display" },
+  { key: "levelLinePoints", label: "Level Line Y Positions (JSON)", type: "string", default: "[]", group: "display" },
+  { key: "showMeasurements", label: "Show Measurements", type: "boolean", default: false, group: "display" },
+  { key: "measurementPairs", label: "Measurement Pairs (JSON)", type: "string", default: "[]", group: "display" },
+  { key: "showSubdivisions", label: "Show Subdivisions", type: "boolean", default: false, group: "display" },
+  { key: "subdivisionDepth", label: "Subdivision Depth", type: "number", default: 1, min: 0, max: 3, step: 1, group: "display" },
+  { key: "envelopeColor", label: "Envelope Color", type: "color", default: "rgba(255,200,0,0.6)", group: "style" },
+  { key: "plumbColor", label: "Plumb Color", type: "color", default: "rgba(0,255,0,0.4)", group: "style" },
+  { key: "measureColor", label: "Measure Color", type: "color", default: "rgba(255,100,100,0.5)", group: "style" },
+  ...COMMON_GUIDE_PROPERTIES
+];
+var envelopeLayerType = {
+  typeId: "construction:envelope",
+  displayName: "Envelope Block-In",
+  icon: "pentagon",
+  category: "guide",
+  properties: ENVELOPE_PROPERTIES,
+  propertyEditorId: "construction:envelope-editor",
+  createDefault() {
+    const props = {};
+    for (const schema of ENVELOPE_PROPERTIES) {
+      props[schema.key] = schema.default;
+    }
+    return props;
+  },
+  render(properties, ctx, bounds) {
+    const pathNorm = parseJSON(properties.envelopePath ?? "[]", []);
+    if (pathNorm.length < 3) return;
+    const style = properties.envelopeStyle ?? "tight";
+    const showAngles = properties.showAngles ?? true;
+    const angleThreshold = properties.angleThreshold ?? 10;
+    const showPlumb = properties.showPlumbLine ?? true;
+    const plumbPt = properties.plumbLinePoint;
+    const showLevel = properties.showLevelLines ?? false;
+    const levelPts = parseJSON(properties.levelLinePoints ?? "[]", []);
+    const showMeasure = properties.showMeasurements ?? false;
+    const measurePairs = parseJSON(properties.measurementPairs ?? "[]", []);
+    const showSub = properties.showSubdivisions ?? false;
+    const subDepth = properties.subdivisionDepth ?? 1;
+    const envColor = properties.envelopeColor ?? "rgba(255,200,0,0.6)";
+    const plumbColor = properties.plumbColor ?? "rgba(0,255,0,0.4)";
+    const measureColor = properties.measureColor ?? "rgba(255,100,100,0.5)";
+    const lineWidth = properties.lineWidth ?? 1;
+    const toPixelPt = (p) => ({
+      x: bounds.x + p.x * bounds.width,
+      y: bounds.y + p.y * bounds.height
+    });
+    const pixelPath = pathNorm.map(toPixelPt);
+    const envelope = computeEnvelope(pixelPath, style);
+    ctx.save();
+    ctx.strokeStyle = envColor;
+    ctx.lineWidth = lineWidth * 1.5;
+    ctx.setLineDash([]);
+    drawPolyline(ctx, envelope, true);
+    if (showAngles) {
+      const angles = envelopeAngles(envelope);
+      for (const { vertex, angle } of angles) {
+        if (Math.abs(angle - 180) > angleThreshold) {
+          drawLabel(ctx, `${Math.round(angle)}\xB0`, vertex.x + 12, vertex.y - 12, envColor, 9);
+          ctx.beginPath();
+          ctx.arc(vertex.x, vertex.y, 8, 0, Math.PI * 2);
+          ctx.strokeStyle = envColor;
+          ctx.lineWidth = 0.5;
+          ctx.stroke();
+        }
+      }
+    }
+    if (showPlumb) {
+      const plumbPixel = toPixelPt(plumbPt ?? { x: 0.5, y: 0 });
+      const [p1, p2] = plumbLine(plumbPixel, bounds);
+      ctx.strokeStyle = plumbColor;
+      ctx.lineWidth = 0.75;
+      drawDashedLine(ctx, p1.x, p1.y, p2.x, p2.y, [8, 6]);
+    }
+    if (showLevel) {
+      ctx.strokeStyle = plumbColor;
+      ctx.lineWidth = 0.75;
+      for (const lp of levelPts) {
+        const py = bounds.y + lp.y * bounds.height;
+        drawDashedLine(ctx, bounds.x, py, bounds.x + bounds.width, py, [8, 6]);
+      }
+    }
+    if (showMeasure) {
+      ctx.strokeStyle = measureColor;
+      ctx.lineWidth = 1;
+      for (const pair of measurePairs) {
+        const from = toPixelPt(pair.from);
+        const to = toPixelPt(pair.to);
+        drawLine(ctx, from.x, from.y, to.x, to.y);
+        const len = dist2(from, to);
+        const midX = (from.x + to.x) / 2;
+        const midY = (from.y + to.y) / 2;
+        drawLabel(ctx, `${Math.round(len)}px`, midX, midY - 8, measureColor, 8);
+      }
+    }
+    if (showSub && subDepth > 0) {
+      ctx.strokeStyle = envColor;
+      ctx.globalAlpha = 0.3;
+      ctx.lineWidth = 0.5;
+      drawSubdivisions(ctx, envelope, subDepth);
+      ctx.globalAlpha = 1;
+    }
+    ctx.restore();
+  },
+  validate(properties) {
+    return null;
+  }
+};
+function drawSubdivisions(ctx, vertices, depth) {
+  if (depth <= 0 || vertices.length < 3) return;
+  const midpoints = [];
+  for (let i = 0; i < vertices.length; i++) {
+    const a = vertices[i];
+    const b = vertices[(i + 1) % vertices.length];
+    midpoints.push({ x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 });
+  }
+  ctx.setLineDash([3, 4]);
+  for (let i = 0; i < midpoints.length; i++) {
+    const a = midpoints[i];
+    const b = midpoints[(i + 1) % midpoints.length];
+    drawLine(ctx, a.x, a.y, b.x, b.y);
+  }
+  if (depth > 1) {
+    drawSubdivisions(ctx, midpoints, depth - 1);
+  }
+}
+
+// src/math/intersection.ts
+function approximateIntersection(form1, form2, samples = 24) {
+  const m1 = rotationMatrix(form1.rotation.x, form1.rotation.y, form1.rotation.z);
+  const m2 = rotationMatrix(form2.rotation.x, form2.rotation.y, form2.rotation.z);
+  const surf1 = sampleFormSurface(form1, m1, samples);
+  const surf2 = sampleFormSurface(form2, m2, samples);
+  const intersectionPoints = [];
+  const threshold = Math.max(
+    form1.size.x,
+    form1.size.y,
+    form1.size.z,
+    form2.size.x,
+    form2.size.y,
+    form2.size.z
+  ) * 0.15;
+  for (const p1 of surf1) {
+    for (const p2 of surf2) {
+      const dx = p1.x - p2.x;
+      const dy = p1.y - p2.y;
+      const dz = p1.z - p2.z;
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (dist < threshold) {
+        intersectionPoints.push({
+          x: (p1.x + p2.x) / 2,
+          y: (p1.y + p2.y) / 2,
+          z: (p1.z + p2.z) / 2
+        });
+      }
+    }
+  }
+  if (intersectionPoints.length < 2) return [];
+  const projected = intersectionPoints.map((p) => project(p, "orthographic"));
+  return orderPointsIntoCurve(projected);
+}
+function sampleFormSurface(form, matrix, samples) {
+  const points = [];
+  const { x: sx, y: sy, z: sz } = form.size;
+  const { x: px, y: py, z: pz } = form.position;
+  switch (form.type) {
+    case "sphere": {
+      for (let i = 0; i < samples; i++) {
+        for (let j = 0; j < samples; j++) {
+          const theta = i / samples * Math.PI;
+          const phi = j / samples * Math.PI * 2;
+          const local = {
+            x: sx * 0.5 * Math.sin(theta) * Math.cos(phi),
+            y: sy * 0.5 * Math.cos(theta),
+            z: sz * 0.5 * Math.sin(theta) * Math.sin(phi)
+          };
+          const rotated = rotate3D(local, matrix);
+          points.push({ x: rotated.x + px, y: rotated.y + py, z: rotated.z + pz });
+        }
+      }
+      break;
+    }
+    case "box": {
+      const half = { x: sx / 2, y: sy / 2, z: sz / 2 };
+      for (let i = 0; i < samples; i++) {
+        for (let j = 0; j < samples; j++) {
+          const u = i / (samples - 1) * 2 - 1;
+          const v = j / (samples - 1) * 2 - 1;
+          const faces = [
+            { x: u * half.x, y: v * half.y, z: half.z },
+            { x: u * half.x, y: v * half.y, z: -half.z },
+            { x: half.x, y: u * half.y, z: v * half.z },
+            { x: -half.x, y: u * half.y, z: v * half.z },
+            { x: u * half.x, y: half.y, z: v * half.z },
+            { x: u * half.x, y: -half.y, z: v * half.z }
+          ];
+          for (const local of faces) {
+            const rotated = rotate3D(local, matrix);
+            points.push({ x: rotated.x + px, y: rotated.y + py, z: rotated.z + pz });
+          }
+        }
+      }
+      break;
+    }
+    case "cylinder": {
+      for (let i = 0; i < samples; i++) {
+        const angle = i / samples * Math.PI * 2;
+        for (let j = 0; j < samples; j++) {
+          const t = j / (samples - 1) * 2 - 1;
+          const local = {
+            x: sx * 0.5 * Math.cos(angle),
+            y: sy * 0.5 * t,
+            z: sz * 0.5 * Math.sin(angle)
+          };
+          const rotated = rotate3D(local, matrix);
+          points.push({ x: rotated.x + px, y: rotated.y + py, z: rotated.z + pz });
+        }
+      }
+      break;
+    }
+    case "cone": {
+      for (let i = 0; i < samples; i++) {
+        const angle = i / samples * Math.PI * 2;
+        for (let j = 0; j < samples; j++) {
+          const t = j / (samples - 1);
+          const radius = 1 - t;
+          const local = {
+            x: sx * 0.5 * radius * Math.cos(angle),
+            y: sy * (t - 0.5),
+            z: sz * 0.5 * radius * Math.sin(angle)
+          };
+          const rotated = rotate3D(local, matrix);
+          points.push({ x: rotated.x + px, y: rotated.y + py, z: rotated.z + pz });
+        }
+      }
+      break;
+    }
+    default: {
+      for (let i = 0; i < samples; i++) {
+        const theta = i / samples * Math.PI;
+        for (let j = 0; j < samples; j++) {
+          const phi = j / samples * Math.PI * 2;
+          const local = {
+            x: sx * 0.5 * Math.sin(theta) * Math.cos(phi),
+            y: sy * 0.5 * Math.cos(theta),
+            z: sz * 0.5 * Math.sin(theta) * Math.sin(phi)
+          };
+          const rotated = rotate3D(local, matrix);
+          points.push({ x: rotated.x + px, y: rotated.y + py, z: rotated.z + pz });
+        }
+      }
+    }
+  }
+  return points;
+}
+function orderPointsIntoCurve(points) {
+  if (points.length < 2) return points;
+  const used = /* @__PURE__ */ new Set();
+  const result = [];
+  let currentIdx = 0;
+  for (let i = 1; i < points.length; i++) {
+    if (points[i].x < points[currentIdx].x) currentIdx = i;
+  }
+  result.push(points[currentIdx]);
+  used.add(currentIdx);
+  while (used.size < points.length) {
+    let bestIdx = -1;
+    let bestDist = Infinity;
+    for (let i = 0; i < points.length; i++) {
+      if (used.has(i)) continue;
+      const dx = points[i].x - points[currentIdx].x;
+      const dy = points[i].y - points[currentIdx].y;
+      const d = dx * dx + dy * dy;
+      if (d < bestDist) {
+        bestDist = d;
+        bestIdx = i;
+      }
+    }
+    if (bestIdx === -1) break;
+    result.push(points[bestIdx]);
+    used.add(bestIdx);
+    currentIdx = bestIdx;
+  }
+  return result;
+}
+
+// src/intersection-layer.ts
+var INTERSECTION_PROPERTIES = [
+  { key: "forms", label: "Forms (JSON)", type: "string", default: "[]", group: "forms" },
+  { key: "showForms", label: "Show Forms", type: "boolean", default: true, group: "display" },
+  { key: "showIntersectionLines", label: "Show Intersection Lines", type: "boolean", default: true, group: "display" },
+  { key: "intersectionWidth", label: "Intersection Width", type: "number", default: 2.5, min: 1, max: 6, step: 0.5, group: "style" },
+  { key: "intersectionColor", label: "Intersection Color", type: "color", default: "rgba(255,50,50,0.8)", group: "style" },
+  {
+    key: "intersectionStyle",
+    label: "Intersection Style",
+    type: "select",
+    default: "solid",
+    options: [
+      { value: "solid", label: "Solid" },
+      { value: "bold", label: "Bold" },
+      { value: "emphasized", label: "Emphasized" }
+    ],
+    group: "style"
+  },
+  { key: "showFormLabels", label: "Show Form Labels", type: "boolean", default: false, group: "display" },
+  {
+    key: "transitionType",
+    label: "Transition Type",
+    type: "select",
+    default: "hard",
+    options: [
+      { value: "hard", label: "Hard" },
+      { value: "soft", label: "Soft" },
+      { value: "mixed", label: "Mixed" }
+    ],
+    group: "display"
+  },
+  ...COMMON_GUIDE_PROPERTIES
+];
+var intersectionLayerType = {
+  typeId: "construction:intersection",
+  displayName: "Form Intersection",
+  icon: "intersect",
+  category: "guide",
+  properties: INTERSECTION_PROPERTIES,
+  propertyEditorId: "construction:intersection-editor",
+  createDefault() {
+    const props = {};
+    for (const schema of INTERSECTION_PROPERTIES) {
+      props[schema.key] = schema.default;
+    }
+    return props;
+  },
+  render(properties, ctx, bounds) {
+    const forms = parseJSON(properties.forms ?? "[]", []);
+    if (forms.length < 2) return;
+    const showForms = properties.showForms ?? true;
+    const showIntersections = properties.showIntersectionLines ?? true;
+    const intWidth = properties.intersectionWidth ?? 2.5;
+    const intColor = properties.intersectionColor ?? "rgba(255,50,50,0.8)";
+    const intStyle = properties.intersectionStyle ?? "solid";
+    const showLabels = properties.showFormLabels ?? false;
+    const transition = properties.transitionType ?? "hard";
+    const guideColor = properties.guideColor ?? "rgba(0,200,255,0.5)";
+    const lineWidth = properties.lineWidth ?? 1;
+    const scale = Math.min(bounds.width, bounds.height) * 0.15;
+    ctx.save();
+    if (showForms) {
+      for (let fi = 0; fi < forms.length; fi++) {
+        const form = forms[fi];
+        const centerNorm = {
+          x: 0.5 + form.position.x * 0.3,
+          y: 0.5 - form.position.y * 0.3
+        };
+        const center = toPixel(centerNorm, bounds);
+        const matrix = rotationMatrix(form.rotation.x, form.rotation.y, form.rotation.z);
+        const baseOpts = {
+          center,
+          scale,
+          sizeX: form.size.x,
+          sizeY: form.size.y,
+          sizeZ: form.size.z,
+          matrix,
+          projection: "orthographic",
+          focalLength: 5,
+          showHidden: true,
+          hiddenStyle: "dashed",
+          hiddenAlpha: 0.2,
+          edgeColor: guideColor
+        };
+        switch (form.type) {
+          case "box":
+            renderBox(ctx, baseOpts);
+            break;
+          case "cylinder":
+            renderCylinder(ctx, baseOpts);
+            break;
+          case "sphere":
+            renderSphere(ctx, { ...baseOpts, radius: 0.5 });
+            break;
+          case "cone":
+            renderCone(ctx, baseOpts);
+            break;
+          case "wedge":
+            renderWedge(ctx, baseOpts);
+            break;
+          case "egg":
+            renderEgg(ctx, baseOpts);
+            break;
+        }
+        if (showLabels) {
+          const label = String.fromCharCode(65 + fi);
+          drawLabel(ctx, label, center.x, center.y - scale * 0.6, guideColor, 12);
+        }
+      }
+    }
+    if (showIntersections) {
+      ctx.strokeStyle = intColor;
+      ctx.lineWidth = intStyle === "bold" ? intWidth * 1.5 : intWidth;
+      ctx.setLineDash(intStyle === "emphasized" ? [2, 0] : []);
+      for (let i = 0; i < forms.length - 1; i++) {
+        for (let j = i + 1; j < forms.length; j++) {
+          const curve = approximateIntersection(forms[i], forms[j], 16);
+          if (curve.length < 2) continue;
+          const screenCurve = curve.map((p) => ({
+            x: bounds.x + bounds.width / 2 + p.x * scale,
+            y: bounds.y + bounds.height / 2 - p.y * scale
+          }));
+          if (transition === "soft") {
+            ctx.lineWidth = intWidth * 2;
+            ctx.globalAlpha = 0.4;
+            drawPolyline(ctx, screenCurve);
+            ctx.globalAlpha = 1;
+            ctx.lineWidth = intWidth;
+          }
+          drawPolyline(ctx, screenCurve);
+        }
+      }
+    }
+    ctx.restore();
+  },
+  validate(properties) {
+    return null;
+  }
+};
+
+// src/construction-tools.ts
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function generateLayerId() {
+  return `layer-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function fullCanvasTransform(ctx) {
+  return {
+    x: 0,
+    y: 0,
+    width: ctx.canvasWidth,
+    height: ctx.canvasHeight,
+    rotation: 0,
+    scaleX: 1,
+    scaleY: 1,
+    anchorX: 0,
+    anchorY: 0
+  };
+}
+function addLayer(context, layer) {
+  context.layers.add(layer);
+  context.emitChange("layer-added");
+}
+var VALID_FORMS = ["box", "cylinder", "sphere", "cone", "wedge", "egg"];
+var addConstructionFormTool = {
+  name: "add_construction_form",
+  description: "Add a 3D construction form guide layer. Form types: box, cylinder, sphere, cone, wedge, egg.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      formType: {
+        type: "string",
+        enum: VALID_FORMS,
+        description: "The form primitive type."
+      },
+      position: {
+        type: "object",
+        properties: { x: { type: "number" }, y: { type: "number" } },
+        description: "Normalized position (0-1). Default: {x:0.5, y:0.5}."
+      },
+      size: { type: "number", description: "Overall form size (0.05-0.6). Default: 0.25." },
+      sizeX: { type: "number", description: "Width scale (0.2-3.0). Default: 1.0." },
+      sizeY: { type: "number", description: "Height scale (0.2-3.0). Default: 1.0." },
+      sizeZ: { type: "number", description: "Depth scale (0.2-3.0). Default: 1.0." },
+      rotationX: { type: "number", description: "X rotation (-90 to 90). Default: 15." },
+      rotationY: { type: "number", description: "Y rotation (-180 to 180). Default: 30." },
+      rotationZ: { type: "number", description: "Z rotation (-180 to 180). Default: 0." },
+      crossContours: { type: "boolean", description: "Show cross-contour lines. Default: true." },
+      projection: {
+        type: "string",
+        enum: ["orthographic", "weak-perspective"],
+        description: "Projection type. Default: orthographic."
+      }
+    },
+    required: ["formType"]
+  },
+  async handler(input, context) {
+    const formType = input.formType;
+    if (!VALID_FORMS.includes(formType)) {
+      return errorResult(`Invalid form type '${formType}'. Use: ${VALID_FORMS.join(", ")}`);
+    }
+    const defaults = formLayerType.createDefault();
+    const properties = { ...defaults, formType };
+    if (input.position) properties.position = input.position;
+    if (input.size !== void 0) properties.formSize = input.size;
+    if (input.sizeX !== void 0) properties.sizeX = input.sizeX;
+    if (input.sizeY !== void 0) properties.sizeY = input.sizeY;
+    if (input.sizeZ !== void 0) properties.sizeZ = input.sizeZ;
+    if (input.rotationX !== void 0) properties.rotationX = input.rotationX;
+    if (input.rotationY !== void 0) properties.rotationY = input.rotationY;
+    if (input.rotationZ !== void 0) properties.rotationZ = input.rotationZ;
+    if (input.crossContours !== void 0) properties.showCrossContours = input.crossContours;
+    if (input.projection !== void 0) properties.projection = input.projection;
+    const id = generateLayerId();
+    addLayer(context, {
+      id,
+      type: "construction:form",
+      name: `Construction Form (${formType})`,
+      visible: true,
+      locked: true,
+      opacity: 1,
+      blendMode: "normal",
+      transform: fullCanvasTransform(context),
+      properties
+    });
+    return textResult(`Added ${formType} construction form '${id}'.`);
+  }
+};
+var addConstructionSceneTool = {
+  name: "add_construction_scene",
+  description: "Add multiple 3D construction forms arranged as a scene.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      forms: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            type: { type: "string", enum: VALID_FORMS },
+            position: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } },
+            size: { type: "number" },
+            rotation: { type: "object", properties: { x: { type: "number" }, y: { type: "number" }, z: { type: "number" } } }
+          },
+          required: ["type"]
+        },
+        description: "Array of form definitions."
+      },
+      showAxes: { type: "boolean", description: "Show axes on all forms. Default: true." }
+    },
+    required: ["forms"]
+  },
+  async handler(input, context) {
+    const formsInput = input.forms;
+    if (!Array.isArray(formsInput) || formsInput.length === 0) {
+      return errorResult("'forms' must be a non-empty array.");
+    }
+    const showAxes = input.showAxes ?? true;
+    const ids = [];
+    for (const f of formsInput) {
+      const formType = f.type;
+      if (!VALID_FORMS.includes(formType)) continue;
+      const defaults = formLayerType.createDefault();
+      const properties = { ...defaults, formType, showAxes };
+      const pos = f.position;
+      if (pos) properties.position = pos;
+      if (f.size !== void 0) properties.formSize = f.size;
+      const rot = f.rotation;
+      if (rot) {
+        properties.rotationX = rot.x ?? 15;
+        properties.rotationY = rot.y ?? 30;
+        properties.rotationZ = rot.z ?? 0;
+      }
+      const id = generateLayerId();
+      ids.push(id);
+      addLayer(context, {
+        id,
+        type: "construction:form",
+        name: `Construction Form (${formType})`,
+        visible: true,
+        locked: true,
+        opacity: 1,
+        blendMode: "normal",
+        transform: fullCanvasTransform(context),
+        properties
+      });
+    }
+    return textResult(`Added ${ids.length} construction form(s): ${ids.join(", ")}.`);
+  }
+};
+var addCrossContoursTool = {
+  name: "add_cross_contours",
+  description: "Add cross-contour lines over an outline + axis path, revealing surface direction on any organic shape.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      outline: { type: "array", items: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } }, description: "Outline points (normalized 0-1)." },
+      axis: { type: "array", items: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } }, description: "Central axis path (normalized 0-1)." },
+      curvature: { type: "number", description: "Curvature 0-1 (0=flat, 0.5=cylindrical, 1=spherical). Default: 0.5." },
+      count: { type: "number", description: "Number of contour lines (2-20). Default: 8." },
+      style: { type: "string", enum: ["elliptical", "angular", "organic"], description: "Contour style. Default: elliptical." },
+      curvatureVariation: { type: "array", items: { type: "number" }, description: "Per-contour curvature overrides." }
+    },
+    required: ["outline", "axis"]
+  },
+  async handler(input, context) {
+    const outline = input.outline;
+    const axis = input.axis;
+    if (!Array.isArray(outline) || !Array.isArray(axis) || axis.length < 2) {
+      return errorResult("'outline' and 'axis' (min 2 points) are required.");
+    }
+    const defaults = crossContourLayerType.createDefault();
+    const properties = {
+      ...defaults,
+      outline: JSON.stringify(outline),
+      axis: JSON.stringify(axis)
+    };
+    if (input.curvature !== void 0) properties.curvature = input.curvature;
+    if (input.count !== void 0) properties.contourCount = input.count;
+    if (input.style !== void 0) properties.contourStyle = input.style;
+    if (input.curvatureVariation !== void 0) {
+      properties.curvatureVariation = JSON.stringify(input.curvatureVariation);
+    }
+    const id = generateLayerId();
+    addLayer(context, {
+      id,
+      type: "construction:cross-contour",
+      name: "Cross-Contour Lines",
+      visible: true,
+      locked: true,
+      opacity: 1,
+      blendMode: "normal",
+      transform: fullCanvasTransform(context),
+      properties
+    });
+    return textResult(`Added cross-contour layer '${id}'.`);
+  }
+};
+var addValueStudyTool = {
+  name: "add_value_study",
+  description: "Add a light/shadow value study overlay with terminator, cast shadow, and value zones.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      lightAzimuth: { type: "number", description: "Light azimuth 0-360 (0=right, 90=bottom). Default: 315." },
+      lightElevation: { type: "number", description: "Light elevation 10-80 degrees. Default: 45." },
+      forms: { type: "array", description: "Optional array of FormDefinition objects." },
+      valueGrouping: { type: "string", enum: ["two-value", "three-value", "five-value"], description: "Value grouping. Default: three-value." },
+      showTerminator: { type: "boolean", description: "Show terminator line. Default: true." }
+    }
+  },
+  async handler(input, context) {
+    const defaults = valueShapesLayerType.createDefault();
+    const properties = { ...defaults };
+    if (input.lightAzimuth !== void 0) properties.lightAzimuth = input.lightAzimuth;
+    if (input.lightElevation !== void 0) properties.lightElevation = input.lightElevation;
+    if (input.forms !== void 0) properties.formData = JSON.stringify(input.forms);
+    if (input.valueGrouping !== void 0) properties.valueGrouping = input.valueGrouping;
+    if (input.showTerminator !== void 0) properties.showTerminator = input.showTerminator;
+    const id = generateLayerId();
+    addLayer(context, {
+      id,
+      type: "construction:value-shapes",
+      name: "Value Study",
+      visible: true,
+      locked: true,
+      opacity: 1,
+      blendMode: "normal",
+      transform: fullCanvasTransform(context),
+      properties
+    });
+    return textResult(`Added value study layer '${id}'.`);
+  }
+};
+var addEnvelopeTool = {
+  name: "add_envelope",
+  description: "Add a straight-line envelope block-in with angle and measurement annotations.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      points: { type: "array", items: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } }, description: "Envelope vertex points (normalized 0-1)." },
+      style: { type: "string", enum: ["tight", "loose", "fitted"], description: "Envelope style. Default: tight." },
+      showAngles: { type: "boolean", description: "Show angle annotations. Default: true." },
+      showPlumbLine: { type: "boolean", description: "Show vertical plumb line. Default: true." },
+      showMeasurements: { type: "boolean", description: "Show comparative measurements. Default: false." }
+    },
+    required: ["points"]
+  },
+  async handler(input, context) {
+    const points = input.points;
+    if (!Array.isArray(points) || points.length < 3) {
+      return errorResult("'points' must have at least 3 vertices.");
+    }
+    const defaults = envelopeLayerType.createDefault();
+    const properties = { ...defaults, envelopePath: JSON.stringify(points) };
+    if (input.style !== void 0) properties.envelopeStyle = input.style;
+    if (input.showAngles !== void 0) properties.showAngles = input.showAngles;
+    if (input.showPlumbLine !== void 0) properties.showPlumbLine = input.showPlumbLine;
+    if (input.showMeasurements !== void 0) properties.showMeasurements = input.showMeasurements;
+    const id = generateLayerId();
+    addLayer(context, {
+      id,
+      type: "construction:envelope",
+      name: "Envelope Block-In",
+      visible: true,
+      locked: true,
+      opacity: 1,
+      blendMode: "normal",
+      transform: fullCanvasTransform(context),
+      properties
+    });
+    return textResult(`Added envelope layer '${id}'.`);
+  }
+};
+var addFormIntersectionTool = {
+  name: "add_form_intersection",
+  description: "Add intersection lines between two or more overlapping 3D forms.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      forms: {
+        type: "array",
+        minItems: 2,
+        items: {
+          type: "object",
+          properties: {
+            type: { type: "string", enum: VALID_FORMS },
+            position: { type: "object", properties: { x: { type: "number" }, y: { type: "number" }, z: { type: "number" } } },
+            size: { type: "object", properties: { x: { type: "number" }, y: { type: "number" }, z: { type: "number" } } },
+            rotation: { type: "object", properties: { x: { type: "number" }, y: { type: "number" }, z: { type: "number" } } }
+          },
+          required: ["type"]
+        },
+        description: "Array of form definitions (at least 2)."
+      },
+      transitionType: { type: "string", enum: ["hard", "soft", "mixed"], description: "Intersection transition type. Default: hard." },
+      showForms: { type: "boolean", description: "Render the forms alongside intersection lines. Default: true." }
+    },
+    required: ["forms"]
+  },
+  async handler(input, context) {
+    const forms = input.forms;
+    if (!Array.isArray(forms) || forms.length < 2) {
+      return errorResult("'forms' must have at least 2 entries.");
+    }
+    const normalizedForms = forms.map((f) => ({
+      type: f.type || "box",
+      position: f.position ?? { x: 0, y: 0, z: 0 },
+      size: f.size ?? { x: 1, y: 1, z: 1 },
+      rotation: f.rotation ?? { x: 0, y: 0, z: 0 }
+    }));
+    const defaults = intersectionLayerType.createDefault();
+    const properties = { ...defaults, forms: JSON.stringify(normalizedForms) };
+    if (input.transitionType !== void 0) properties.transitionType = input.transitionType;
+    if (input.showForms !== void 0) properties.showForms = input.showForms;
+    const id = generateLayerId();
+    addLayer(context, {
+      id,
+      type: "construction:intersection",
+      name: "Form Intersection",
+      visible: true,
+      locked: true,
+      opacity: 1,
+      blendMode: "normal",
+      transform: fullCanvasTransform(context),
+      properties
+    });
+    return textResult(`Added form intersection layer '${id}'.`);
+  }
+};
+var generateExerciseTool = {
+  name: "generate_construction_exercise",
+  description: "Generate a random construction exercise with forms at varying difficulty.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      difficulty: { type: "string", enum: ["beginner", "intermediate", "advanced"], description: "Exercise difficulty. Default: beginner." },
+      formCount: { type: "number", description: "Number of forms (overrides difficulty default)." },
+      seed: { type: "number", description: "Random seed for reproducibility." },
+      includeValues: { type: "boolean", description: "Include a value study overlay. Default: false." },
+      includeIntersections: { type: "boolean", description: "Include intersection lines. Default: false." }
+    }
+  },
+  async handler(input, context) {
+    const difficulty = input.difficulty ?? "beginner";
+    const seed = input.seed ?? Date.now();
+    const includeValues = input.includeValues ?? false;
+    const includeIntersections = input.includeIntersections ?? false;
+    let s = seed;
+    const rand = () => {
+      s = s * 1103515245 + 12345 & 2147483647;
+      return s / 2147483647;
+    };
+    const defaultCounts = { beginner: 1, intermediate: 3, advanced: 5 };
+    const formCount = input.formCount ?? defaultCounts[difficulty] ?? 1;
+    const ids = [];
+    const maxRotation = { beginner: 30, intermediate: 60, advanced: 90 };
+    const rotLimit = maxRotation[difficulty] ?? 30;
+    for (let i = 0; i < formCount; i++) {
+      const typeIdx = Math.floor(rand() * VALID_FORMS.length);
+      const formType = VALID_FORMS[typeIdx];
+      const posSpread = difficulty === "beginner" ? 0 : 0.3;
+      const defaults = formLayerType.createDefault();
+      const properties = {
+        ...defaults,
+        formType,
+        position: { x: 0.5 + (rand() - 0.5) * posSpread, y: 0.5 + (rand() - 0.5) * posSpread },
+        formSize: 0.15 + rand() * 0.15,
+        rotationX: Math.round((rand() - 0.5) * 2 * rotLimit / 5) * 5,
+        rotationY: Math.round((rand() - 0.5) * 2 * 180 / 5) * 5,
+        rotationZ: difficulty === "advanced" ? Math.round((rand() - 0.5) * 2 * 45 / 5) * 5 : 0,
+        showCrossContours: true,
+        showAxes: true
+      };
+      const id = generateLayerId();
+      ids.push(id);
+      addLayer(context, {
+        id,
+        type: "construction:form",
+        name: `Exercise Form ${i + 1} (${formType})`,
+        visible: true,
+        locked: true,
+        opacity: 1,
+        blendMode: "normal",
+        transform: fullCanvasTransform(context),
+        properties
+      });
+    }
+    if (includeValues) {
+      const valDefaults = valueShapesLayerType.createDefault();
+      const valId = generateLayerId();
+      ids.push(valId);
+      addLayer(context, {
+        id: valId,
+        type: "construction:value-shapes",
+        name: "Exercise Value Study",
+        visible: true,
+        locked: true,
+        opacity: 1,
+        blendMode: "normal",
+        transform: fullCanvasTransform(context),
+        properties: { ...valDefaults, lightAzimuth: Math.round(rand() * 360 / 15) * 15 }
+      });
+    }
+    return textResult(`Generated ${difficulty} exercise with ${formCount} form(s): ${ids.join(", ")}.`);
+  }
+};
+var clearConstructionGuidesTool = {
+  name: "clear_construction_guides",
+  description: "Remove all construction:* layers from the layer stack.",
+  inputSchema: { type: "object", properties: {} },
+  async handler(_input, context) {
+    const layers = context.layers.getAll();
+    const ids = layers.filter((l) => l.type.startsWith("construction:")).map((l) => l.id);
+    if (ids.length === 0) return textResult("No construction layers to remove.");
+    for (const id of ids) context.layers.remove(id);
+    context.emitChange("layer-removed");
+    return textResult(`Removed ${ids.length} construction layer(s).`);
+  }
+};
+var constructionMcpTools = [
+  addConstructionFormTool,
+  addConstructionSceneTool,
+  addCrossContoursTool,
+  addValueStudyTool,
+  addEnvelopeTool,
+  addFormIntersectionTool,
+  generateExerciseTool,
+  clearConstructionGuidesTool
+];
+
+// src/index.ts
+var constructionPlugin = {
+  id: "construction",
+  name: "Construction Guides",
+  version: "0.1.0",
+  tier: "free",
+  description: "Drawing construction guides: 3D form primitives, cross-contour lines, value/shadow studies, envelope block-ins, and form intersections.",
+  layerTypes: [
+    formLayerType,
+    crossContourLayerType,
+    valueShapesLayerType,
+    envelopeLayerType,
+    intersectionLayerType
+  ],
+  tools: [],
+  exportHandlers: [],
+  mcpTools: constructionMcpTools,
+  async initialize(_context) {
+  },
+  dispose() {
+  }
+};
+var index_default = constructionPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  approximateIntersection,
+  castShadow,
+  clamp,
+  comparativeMeasure,
+  computeEnvelope,
+  constructionMcpTools,
+  cross3,
+  crossContourLayerType,
+  dot3,
+  drawEllipse,
+  drawEllipseWithHidden,
+  ellipsePoints,
+  envelopeAngles,
+  envelopeLayerType,
+  formLayerType,
+  identityMatrix,
+  intersectionLayerType,
+  levelLine,
+  lightDirection,
+  lightDirection2D,
+  multiplyMat3,
+  normalize3,
+  plumbLine,
+  project,
+  projectedEllipse,
+  rotate3D,
+  rotationMatrix,
+  sphereTerminator,
+  sphereValueZones,
+  transformPoint,
+  transformedNormalZ,
+  valueShapesLayerType
+});
+//# sourceMappingURL=index.cjs.map