@kekonic/diagrams-geometry 1.0.0-rc.4

package/dist/index.mjs

@@ -0,0 +1,2420 @@
+import { BUILTIN_KIND_CATALOG, normalizeShapeId as normalizeShapeId$1 } from "@kekonic/diagrams-core";
+//#region src/types.ts
+const CLEAR_SPACE_PRESETS = {
+	compact: 10,
+	standard: 20,
+	presentation: 32
+};
+const EDGE_LAUNCH_PRESETS = {
+	compact: 10,
+	standard: 16,
+	presentation: 24
+};
+/** Minimum interactive target in logical units (ports / markers). */
+const MIN_INTERACTION_TARGET = 22;
+const DEFAULT_STROKE_WIDTH = 1.6;
+function uniformInsets(n) {
+	return {
+		top: n,
+		right: n,
+		bottom: n,
+		left: n
+	};
+}
+function insets(partial, fallback = 0) {
+	return {
+		top: partial.top ?? fallback,
+		right: partial.right ?? fallback,
+		bottom: partial.bottom ?? fallback,
+		left: partial.left ?? fallback
+	};
+}
+function insetRect(r, pad) {
+	const p = typeof pad === "number" ? uniformInsets(pad) : pad;
+	return {
+		x: r.x + p.left,
+		y: r.y + p.top,
+		width: Math.max(0, r.width - p.left - p.right),
+		height: Math.max(0, r.height - p.top - p.bottom)
+	};
+}
+function expandRectInsets(r, pad) {
+	const p = typeof pad === "number" ? uniformInsets(pad) : pad;
+	return {
+		x: r.x - p.left,
+		y: r.y - p.top,
+		width: r.width + p.left + p.right,
+		height: r.height + p.top + p.bottom
+	};
+}
+function unionRects(rects) {
+	if (rects.length === 0) return {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const r of rects) {
+		minX = Math.min(minX, r.x);
+		minY = Math.min(minY, r.y);
+		maxX = Math.max(maxX, r.x + r.width);
+		maxY = Math.max(maxY, r.y + r.height);
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+function rectFromSize(size, origin = {
+	x: 0,
+	y: 0
+}) {
+	return {
+		x: origin.x,
+		y: origin.y,
+		width: size.width,
+		height: size.height
+	};
+}
+function normalizeVector(v) {
+	const len = Math.hypot(v.x, v.y) || 1;
+	return {
+		x: v.x / len,
+		y: v.y / len
+	};
+}
+function sideNormal(side) {
+	switch (side) {
+		case "north": return {
+			x: 0,
+			y: -1
+		};
+		case "east": return {
+			x: 1,
+			y: 0
+		};
+		case "south": return {
+			x: 0,
+			y: 1
+		};
+		case "west": return {
+			x: -1,
+			y: 0
+		};
+	}
+}
+function sideMidpoint(bounds, side) {
+	const cx = bounds.x + bounds.width / 2;
+	const cy = bounds.y + bounds.height / 2;
+	switch (side) {
+		case "north": return {
+			x: cx,
+			y: bounds.y
+		};
+		case "east": return {
+			x: bounds.x + bounds.width,
+			y: cy
+		};
+		case "south": return {
+			x: cx,
+			y: bounds.y + bounds.height
+		};
+		case "west": return {
+			x: bounds.x,
+			y: cy
+		};
+	}
+}
+//#endregion
+//#region src/math.ts
+/** Ray from origin along direction; returns closest intersection with t >= 0. */
+function intersectRayPolygon(polygon, origin, direction) {
+	if (polygon.length < 3) return null;
+	const dir = normalizeVector(direction);
+	let bestT = Infinity;
+	let best = null;
+	for (let i = 0; i < polygon.length; i++) {
+		const a = polygon[i];
+		const b = polygon[(i + 1) % polygon.length];
+		const hit = raySegmentIntersection(origin, dir, a, b);
+		if (hit && hit.t >= 0 && hit.t < bestT) {
+			bestT = hit.t;
+			best = hit.point;
+		}
+	}
+	return best;
+}
+function raySegmentIntersection(origin, dir, a, b) {
+	const sx = b.x - a.x;
+	const sy = b.y - a.y;
+	const denom = dir.x * sy - dir.y * sx;
+	if (Math.abs(denom) < 1e-9) return null;
+	const qx = a.x - origin.x;
+	const qy = a.y - origin.y;
+	const t = (qx * sy - qy * sx) / denom;
+	const u = (qx * dir.y - qy * dir.x) / denom;
+	if (u < -1e-9 || u > 1.000000001) return null;
+	return {
+		t,
+		point: {
+			x: origin.x + dir.x * t,
+			y: origin.y + dir.y * t
+		}
+	};
+}
+/** Ellipse / circle ray intersection (axis-aligned). */
+function intersectRayEllipse(bounds, origin, direction) {
+	const cx = bounds.x + bounds.width / 2;
+	const cy = bounds.y + bounds.height / 2;
+	const rx = bounds.width / 2;
+	const ry = bounds.height / 2;
+	if (rx <= 0 || ry <= 0) return null;
+	const dir = normalizeVector(direction);
+	const ox = (origin.x - cx) / rx;
+	const oy = (origin.y - cy) / ry;
+	const dx = dir.x / rx;
+	const dy = dir.y / ry;
+	const a = dx * dx + dy * dy;
+	const b = 2 * (ox * dx + oy * dy);
+	const c = ox * ox + oy * oy - 1;
+	const disc = b * b - 4 * a * c;
+	if (disc < 0 || a === 0) return null;
+	const sqrt = Math.sqrt(disc);
+	const candidates = [(-b - sqrt) / (2 * a), (-b + sqrt) / (2 * a)].filter((t) => t >= 0);
+	if (!candidates.length) return null;
+	const t = Math.min(...candidates);
+	return {
+		x: origin.x + dir.x * t,
+		y: origin.y + dir.y * t
+	};
+}
+/** Axis-aligned rect ray intersection. */
+function intersectRayRect(bounds, origin, direction) {
+	return intersectRayPolygon(rectPolygon(bounds), origin, direction);
+}
+function rectPolygon(bounds) {
+	return [
+		{
+			x: bounds.x,
+			y: bounds.y
+		},
+		{
+			x: bounds.x + bounds.width,
+			y: bounds.y
+		},
+		{
+			x: bounds.x + bounds.width,
+			y: bounds.y + bounds.height
+		},
+		{
+			x: bounds.x,
+			y: bounds.y + bounds.height
+		}
+	];
+}
+function pointInPolygon(point, polygon) {
+	let inside = false;
+	for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+		const pi = polygon[i];
+		const pj = polygon[j];
+		if (pi.y > point.y !== pj.y > point.y && point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y + 1e-12) + pi.x) inside = !inside;
+	}
+	return inside;
+}
+function pointInEllipse(point, bounds) {
+	const cx = bounds.x + bounds.width / 2;
+	const cy = bounds.y + bounds.height / 2;
+	const rx = bounds.width / 2;
+	const ry = bounds.height / 2;
+	if (rx <= 0 || ry <= 0) return false;
+	const dx = (point.x - cx) / rx;
+	const dy = (point.y - cy) / ry;
+	return dx * dx + dy * dy <= 1;
+}
+function polygonToPath(points, close = true) {
+	if (!points.length) return "";
+	const [first, ...rest] = points;
+	let d = `M ${first.x} ${first.y}`;
+	for (const p of rest) d += ` L ${p.x} ${p.y}`;
+	if (close) d += " Z";
+	return d;
+}
+/**
+* Closed Catmull–Rom spline as cubic Béziers.
+* Yields smooth SVG path data (`C` commands) from a polygon of control points.
+*/
+function closedCatmullRomToPath(points) {
+	if (points.length < 3) return polygonToPath(points);
+	const n = points.length;
+	const first = points[0];
+	let d = `M ${first.x} ${first.y}`;
+	for (let i = 0; i < n; i++) {
+		const p0 = points[(i - 1 + n) % n];
+		const p1 = points[i];
+		const p2 = points[(i + 1) % n];
+		const p3 = points[(i + 2) % n];
+		const c1x = p1.x + (p2.x - p0.x) / 6;
+		const c1y = p1.y + (p2.y - p0.y) / 6;
+		const c2x = p2.x - (p3.x - p1.x) / 6;
+		const c2y = p2.y - (p3.y - p1.y) / 6;
+		d += ` C ${c1x} ${c1y}, ${c2x} ${c2y}, ${p2.x} ${p2.y}`;
+	}
+	return `${d} Z`;
+}
+/** Inscribed content rect as a fraction of geometry bounds, centered. */
+function centeredContentRect(bounds, widthRatio, heightRatio) {
+	const w = bounds.width * widthRatio;
+	const h = bounds.height * heightRatio;
+	return {
+		x: bounds.x + (bounds.width - w) / 2,
+		y: bounds.y + (bounds.height - h) / 2,
+		width: w,
+		height: h
+	};
+}
+/** Stroke expands visual bounds by half stroke on each side. */
+function strokeOutset(strokeWidth) {
+	return Math.max(0, strokeWidth / 2);
+}
+//#endregion
+//#region src/shape-geometry.ts
+/** Assemble the full node bounds model from a geometry + style + context. */
+function buildNodeBoundsModel(geometry, bounds, style = {}, context = {}) {
+	const content = geometry.getContentBounds(bounds, style);
+	const extras = [geometry.getVisualBounds(bounds, style)];
+	if (context.externalLabels) extras.push(...context.externalLabels);
+	if (context.badges) extras.push(...context.badges);
+	const visualWithChrome = unionRects(extras);
+	const density = context.density ?? "standard";
+	const baseClear = CLEAR_SPACE_PRESETS[density];
+	const boost = geometry.clearSpaceBoost ?? 0;
+	const clearSpace = insets(context.clearSpace ?? {}, baseClear + boost);
+	const launch = context.edgeLaunch ?? EDGE_LAUNCH_PRESETS[density];
+	const footprint = expandRectInsets(visualWithChrome, {
+		top: clearSpace.top + launch,
+		right: clearSpace.right + launch,
+		bottom: clearSpace.bottom + launch,
+		left: clearSpace.left + launch
+	});
+	const interactionPad = Math.max(0, (22 - Math.min(bounds.width, bounds.height)) / 2);
+	const interaction = interactionPad > 0 ? expandRectInsets(visualWithChrome, interactionPad) : visualWithChrome;
+	return {
+		geometry: { ...bounds },
+		content,
+		visual: visualWithChrome,
+		interaction,
+		footprint,
+		clearSpace
+	};
+}
+/** Shared helpers for concrete geometries. */
+function defaultVisualBounds(bounds, style = {}) {
+	let visual = expandRectInsets(bounds, strokeOutset(style.strokeWidth ?? 1.6));
+	if (style.shadowBlur || style.shadowOffsetX || style.shadowOffsetY) {
+		const blur = style.shadowBlur ?? 0;
+		const ox = style.shadowOffsetX ?? 0;
+		const oy = style.shadowOffsetY ?? 0;
+		visual = unionRects([visual, {
+			x: bounds.x + Math.min(0, ox) - blur,
+			y: bounds.y + Math.min(0, oy) - blur,
+			width: bounds.width + Math.abs(ox) + blur * 2,
+			height: bounds.height + Math.abs(oy) + blur * 2
+		}]);
+	}
+	return visual;
+}
+function defaultLayoutFootprint(geometry, bounds, context = {}, style = {}) {
+	return buildNodeBoundsModel(geometry, bounds, style, context).footprint;
+}
+function defaultSidePortPosition(port, bounds) {
+	if (port.kind === "center") return {
+		x: bounds.x + bounds.width / 2,
+		y: bounds.y + bounds.height / 2
+	};
+	if (port.kind === "corner") switch (port.corner) {
+		case "northwest": return {
+			x: bounds.x,
+			y: bounds.y
+		};
+		case "northeast": return {
+			x: bounds.x + bounds.width,
+			y: bounds.y
+		};
+		case "southeast": return {
+			x: bounds.x + bounds.width,
+			y: bounds.y + bounds.height
+		};
+		case "southwest": return {
+			x: bounds.x,
+			y: bounds.y + bounds.height
+		};
+	}
+	if (port.kind === "radial") {
+		const cx = bounds.x + bounds.width / 2;
+		const cy = bounds.y + bounds.height / 2;
+		const rad = port.angleDeg * Math.PI / 180;
+		return {
+			x: cx + Math.cos(rad) * (bounds.width / 2),
+			y: cy + Math.sin(rad) * (bounds.height / 2)
+		};
+	}
+	if (port.kind === "named") return sideMidpoint(bounds, "east");
+	const side = port.side;
+	const count = Math.max(1, port.count ?? 1);
+	const index = Math.min(Math.max(0, port.index ?? 0), count - 1);
+	if (count === 1) return sideMidpoint(bounds, side);
+	return distributedSidePort(bounds, side, index, count);
+}
+/**
+* Place a side port on a non-rect silhouette.
+* Starts from the AABB mid/distributed point, then casts from the shape center
+* onto the outline so FIXED_POS pins and perimeter snap share one attach truth.
+*/
+function projectSidePortOntoOutline(port, bounds, hitFromCenter) {
+	const bboxPt = defaultSidePortPosition(port, bounds);
+	if (port.kind !== "side") return bboxPt;
+	const cx = bounds.x + bounds.width / 2;
+	const cy = bounds.y + bounds.height / 2;
+	const direction = {
+		x: bboxPt.x - cx,
+		y: bboxPt.y - cy
+	};
+	if (Math.hypot(direction.x, direction.y) < 1e-9) return bboxPt;
+	return hitFromCenter(direction) ?? bboxPt;
+}
+/** Convenience: project onto a polygon silhouette via center→AABB ray. */
+function projectSidePortOntoPolygon(port, bounds, polygon, intersect) {
+	return projectSidePortOntoOutline(port, bounds, (direction) => intersect(polygon, {
+		x: bounds.x + bounds.width / 2,
+		y: bounds.y + bounds.height / 2
+	}, direction));
+}
+function distributedSidePort(bounds, side, index, count, sideInset = 8) {
+	const usable = side === "north" || side === "south" ? Math.max(0, bounds.width - sideInset * 2) : Math.max(0, bounds.height - sideInset * 2);
+	const offset = sideInset + (count > 1 ? usable / (count - 1) : 0) * index;
+	switch (side) {
+		case "north": return {
+			x: bounds.x + offset,
+			y: bounds.y
+		};
+		case "south": return {
+			x: bounds.x + offset,
+			y: bounds.y + bounds.height
+		};
+		case "east": return {
+			x: bounds.x + bounds.width,
+			y: bounds.y + offset
+		};
+		case "west": return {
+			x: bounds.x,
+			y: bounds.y + offset
+		};
+	}
+}
+function defaultPortNormal(port, _bounds) {
+	if (port.kind === "side") return sideNormal(port.side);
+	if (port.kind === "corner") switch (port.corner) {
+		case "northwest": return normalizeVec({
+			x: -1,
+			y: -1
+		});
+		case "northeast": return normalizeVec({
+			x: 1,
+			y: -1
+		});
+		case "southeast": return normalizeVec({
+			x: 1,
+			y: 1
+		});
+		case "southwest": return normalizeVec({
+			x: -1,
+			y: 1
+		});
+	}
+	if (port.kind === "radial") {
+		const rad = port.angleDeg * Math.PI / 180;
+		return {
+			x: Math.cos(rad),
+			y: Math.sin(rad)
+		};
+	}
+	if (port.kind === "center") return {
+		x: 1,
+		y: 0
+	};
+	return {
+		x: 1,
+		y: 0
+	};
+}
+function normalizeVec(v) {
+	const len = Math.hypot(v.x, v.y) || 1;
+	return {
+		x: v.x / len,
+		y: v.y / len
+	};
+}
+//#endregion
+//#region src/shapes/rectangle.ts
+function resolveRadius(bounds, style, opts) {
+	if (opts.pill) return bounds.height / 2;
+	const configured = style?.cornerRadius ?? opts.cornerRadius ?? 0;
+	return Math.min(configured, bounds.width / 2, bounds.height / 2);
+}
+/** Sampled rounded-rect / capsule outline for ports, rays, and hit tests. */
+function roundedRectPolygon(bounds, r, arcSamples = 6) {
+	if (r <= 0) return rectPolygon(bounds);
+	const { x, y, width, height } = bounds;
+	const radius = Math.min(r, width / 2, height / 2);
+	const pts = [];
+	const arc = (cx, cy, start, end) => {
+		for (let i = 0; i <= arcSamples; i++) {
+			const t = start + (end - start) * i / arcSamples;
+			pts.push({
+				x: cx + radius * Math.cos(t),
+				y: cy + radius * Math.sin(t)
+			});
+		}
+	};
+	arc(x + radius, y + radius, -Math.PI, -Math.PI / 2);
+	arc(x + width - radius, y + radius, -Math.PI / 2, 0);
+	arc(x + width - radius, y + height - radius, 0, Math.PI / 2);
+	arc(x + radius, y + height - radius, Math.PI / 2, Math.PI);
+	return pts;
+}
+function createRectangleGeometry(opts = { id: "rectangle" }) {
+	const geometry = {
+		id: opts.id,
+		defaultSize: opts.defaultSize ?? {
+			width: 160,
+			height: 72
+		},
+		minSize: opts.minSize ?? {
+			width: 48,
+			height: 32
+		},
+		defaultPadding: opts.defaultPadding ?? {
+			top: 16,
+			right: 18,
+			bottom: 16,
+			left: 18
+		},
+		contentPolicy: opts.contentPolicy ?? {
+			align: "start",
+			maxLabelLines: 2,
+			iconPlacement: "leading"
+		},
+		getPath(bounds, style = {}) {
+			const r = resolveRadius(bounds, style, opts);
+			const { x, y, width, height } = bounds;
+			if (r <= 0) {
+				const polygon = rectPolygon(bounds);
+				return {
+					d: polygonToPath(polygon),
+					polygon
+				};
+			}
+			return {
+				d: [
+					`M ${x + r} ${y}`,
+					`L ${x + width - r} ${y}`,
+					`A ${r} ${r} 0 0 1 ${x + width} ${y + r}`,
+					`L ${x + width} ${y + height - r}`,
+					`A ${r} ${r} 0 0 1 ${x + width - r} ${y + height}`,
+					`L ${x + r} ${y + height}`,
+					`A ${r} ${r} 0 0 1 ${x} ${y + height - r}`,
+					`L ${x} ${y + r}`,
+					`A ${r} ${r} 0 0 1 ${x + r} ${y}`,
+					`Z`
+				].join(" "),
+				polygon: roundedRectPolygon(bounds, r)
+			};
+		},
+		getContentBounds(bounds, style = {}) {
+			const stroke = style.strokeWidth ?? 1.6;
+			const r = resolveRadius(bounds, style, opts);
+			return insetRect(bounds, Math.max(stroke, r > 0 ? r * .35 : 0) + 2);
+		},
+		getVisualBounds(bounds, style) {
+			return defaultVisualBounds(bounds, style);
+		},
+		getLayoutFootprint(bounds, context, style) {
+			return defaultLayoutFootprint(geometry, bounds, context, style);
+		},
+		getPortPosition(port, bounds, style = {}) {
+			const r = resolveRadius(bounds, style, opts);
+			if (r <= 0) return defaultSidePortPosition(port, bounds);
+			return projectSidePortOntoPolygon(port, bounds, roundedRectPolygon(bounds, r), intersectRayPolygon);
+		},
+		getPortNormal(port, bounds) {
+			return defaultPortNormal(port, bounds);
+		},
+		intersectRay(bounds, origin, direction, style = {}) {
+			const r = resolveRadius(bounds, style, opts);
+			if (r <= 0) return intersectRayRect(bounds, origin, direction);
+			return intersectRayPolygon(roundedRectPolygon(bounds, r), origin, direction);
+		},
+		containsPoint(bounds, point, style = {}) {
+			const r = resolveRadius(bounds, style, opts);
+			if (r <= 0) return pointInPolygon(point, rectPolygon(bounds));
+			return pointInPolygon(point, roundedRectPolygon(bounds, r));
+		}
+	};
+	return geometry;
+}
+const rectangleGeometry = createRectangleGeometry({ id: "rectangle" });
+const roundedRectangleGeometry = createRectangleGeometry({
+	id: "rounded",
+	cornerRadius: 12,
+	contentPolicy: {
+		align: "start",
+		maxLabelLines: 2,
+		iconPlacement: "leading"
+	}
+});
+const pillGeometry = createRectangleGeometry({
+	id: "pill",
+	pill: true,
+	defaultSize: {
+		width: 120,
+		height: 40
+	},
+	contentPolicy: {
+		align: "center",
+		maxLabelLines: 1,
+		iconPlacement: "leading"
+	}
+});
+//#endregion
+//#region src/shapes/diamond.ts
+/** Diamond tips sit on bbox mid-sides so LR/TD ports land on vertices. */
+function diamondPolygon(bounds) {
+	const cx = bounds.x + bounds.width / 2;
+	const cy = bounds.y + bounds.height / 2;
+	return [
+		{
+			x: cx,
+			y: bounds.y
+		},
+		{
+			x: bounds.x + bounds.width,
+			y: cy
+		},
+		{
+			x: cx,
+			y: bounds.y + bounds.height
+		},
+		{
+			x: bounds.x,
+			y: cy
+		}
+	];
+}
+function diamondPointsString(bounds) {
+	return diamondPolygon(bounds).map((p) => `${p.x},${p.y}`).join(" ");
+}
+const diamondGeometry = {
+	id: "diamond",
+	defaultSize: {
+		width: 140,
+		height: 100
+	},
+	minSize: {
+		width: 64,
+		height: 64
+	},
+	defaultPadding: {
+		top: 12,
+		right: 12,
+		bottom: 12,
+		left: 12
+	},
+	contentPolicy: {
+		align: "center",
+		maxLabelLines: 2,
+		preferExternalLabel: false,
+		iconPlacement: "none"
+	},
+	clearSpaceBoost: 6,
+	getPath(bounds) {
+		const polygon = diamondPolygon(bounds);
+		return {
+			d: polygonToPath(polygon),
+			polygon
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		const stroke = style.strokeWidth ?? 1.6;
+		return insetRect(centeredContentRect(bounds, .5, .5), stroke);
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(diamondGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		return projectSidePortOntoPolygon(port, bounds, diamondPolygon(bounds), intersectRayPolygon);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayPolygon(diamondPolygon(bounds), origin, direction);
+	},
+	containsPoint(bounds, point) {
+		return pointInPolygon(point, diamondPolygon(bounds));
+	}
+};
+//#endregion
+//#region src/shapes/hexagon.ts
+/** Flat-top hexagon inset: height-led so wide short nodes keep real chamfers. */
+function hexagonInset(width, height) {
+	return Math.min(width * .22, height * .42, width * .5 - 4);
+}
+function hexagonPolygon(bounds) {
+	const { x, y, width, height } = bounds;
+	const inset = hexagonInset(width, height);
+	const midY = y + height / 2;
+	return [
+		{
+			x: x + inset,
+			y
+		},
+		{
+			x: x + width - inset,
+			y
+		},
+		{
+			x: x + width,
+			y: midY
+		},
+		{
+			x: x + width - inset,
+			y: y + height
+		},
+		{
+			x: x + inset,
+			y: y + height
+		},
+		{
+			x,
+			y: midY
+		}
+	];
+}
+function hexagonPointsString(bounds) {
+	return hexagonPolygon(bounds).map((p) => `${p.x},${p.y}`).join(" ");
+}
+function createHexGeometry(id) {
+	const geometry = {
+		id,
+		defaultSize: {
+			width: 160,
+			height: 72
+		},
+		minSize: {
+			width: 72,
+			height: 40
+		},
+		defaultPadding: {
+			top: 14,
+			right: 20,
+			bottom: 14,
+			left: 20
+		},
+		contentPolicy: {
+			align: "center",
+			maxLabelLines: 2,
+			iconPlacement: "none"
+		},
+		getPath(bounds) {
+			const polygon = hexagonPolygon(bounds);
+			return {
+				d: polygonToPath(polygon),
+				polygon
+			};
+		},
+		getContentBounds(bounds, style = {}) {
+			const stroke = style.strokeWidth ?? 1.6;
+			const inset = hexagonInset(bounds.width, bounds.height);
+			return {
+				x: bounds.x + inset,
+				y: bounds.y + stroke + 4,
+				width: Math.max(0, bounds.width - inset * 2),
+				height: Math.max(0, bounds.height - (stroke + 4) * 2)
+			};
+		},
+		getVisualBounds(bounds, style) {
+			return defaultVisualBounds(bounds, style);
+		},
+		getLayoutFootprint(bounds, context, style) {
+			return defaultLayoutFootprint(geometry, bounds, context, style);
+		},
+		getPortPosition(port, bounds) {
+			return projectSidePortOntoPolygon(port, bounds, hexagonPolygon(bounds), intersectRayPolygon);
+		},
+		getPortNormal(port, bounds) {
+			return defaultPortNormal(port, bounds);
+		},
+		intersectRay(bounds, origin, direction) {
+			return intersectRayPolygon(hexagonPolygon(bounds), origin, direction);
+		},
+		containsPoint(bounds, point) {
+			return pointInPolygon(point, hexagonPolygon(bounds));
+		}
+	};
+	return geometry;
+}
+const hexagonGeometry = createHexGeometry("hexagon");
+//#endregion
+//#region src/shapes/cylinder.ts
+function cylinderRadii(width, height) {
+	return {
+		rx: width / 2,
+		ry: Math.min(Math.max(width * .125, 7), height * .16, 13)
+	};
+}
+/**
+* Cylinder as one closed silhouette + front rim arc.
+* Prefer a single coordinated path set for intersection/hit testing.
+*/
+function cylinderPaths(bounds) {
+	const { x, y, width, height } = bounds;
+	const { rx, ry } = cylinderRadii(width, height);
+	return {
+		body: [
+			`M ${x} ${y + ry}`,
+			`a ${rx} ${ry} 0 0 1 ${width} 0`,
+			`l 0 ${height - 2 * ry}`,
+			`a ${rx} ${ry} 0 0 1 ${-width} 0`,
+			`z`
+		].join(" "),
+		rim: `M ${x} ${y + ry} a ${rx} ${ry} 0 0 0 ${width} 0`
+	};
+}
+/**
+* Sampled silhouette matching `cylinderPaths` body (top arc → right side → bottom arc → left).
+* Used for perimeter attachment so tall cylinders hit vertical walls, not a bounding ellipse.
+*/
+function cylinderSilhouettePolygon(bounds, samplesPerCap = 16) {
+	const { x, y, width, height } = bounds;
+	const { rx, ry } = cylinderRadii(width, height);
+	const cx = x + rx;
+	const pts = [];
+	for (let i = 0; i <= samplesPerCap; i++) {
+		const t = Math.PI - i / samplesPerCap * Math.PI;
+		pts.push({
+			x: cx + rx * Math.cos(t),
+			y: y + ry - ry * Math.sin(t)
+		});
+	}
+	for (let i = 0; i <= samplesPerCap; i++) {
+		const t = i / samplesPerCap * Math.PI;
+		pts.push({
+			x: cx + rx * Math.cos(t),
+			y: y + height - ry + ry * Math.sin(t)
+		});
+	}
+	return pts;
+}
+const cylinderGeometry = {
+	id: "cylinder",
+	defaultSize: {
+		width: 140,
+		height: 88
+	},
+	minSize: {
+		width: 64,
+		height: 56
+	},
+	defaultPadding: {
+		top: 22,
+		right: 16,
+		bottom: 14,
+		left: 16
+	},
+	contentPolicy: {
+		align: "center",
+		maxLabelLines: 2,
+		iconPlacement: "none"
+	},
+	getPath(bounds) {
+		const { body, rim } = cylinderPaths(bounds);
+		return {
+			d: body,
+			decorations: [{
+				d: rim,
+				role: "rim"
+			}]
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		const stroke = style.strokeWidth ?? 1.6;
+		const { ry } = cylinderRadii(bounds.width, bounds.height);
+		const topReserve = Math.max(ry * 2, bounds.height * .22);
+		return {
+			x: bounds.x + stroke + 8,
+			y: bounds.y + topReserve,
+			width: Math.max(0, bounds.width - (stroke + 8) * 2),
+			height: Math.max(0, bounds.height - topReserve - stroke - 8)
+		};
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(cylinderGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		return projectSidePortOntoPolygon(port, bounds, cylinderSilhouettePolygon(bounds), intersectRayPolygon);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayPolygon(cylinderSilhouettePolygon(bounds), origin, direction);
+	},
+	containsPoint(bounds, point) {
+		const { ry } = cylinderRadii(bounds.width, bounds.height);
+		const top = {
+			x: bounds.x,
+			y: bounds.y,
+			width: bounds.width,
+			height: ry * 2
+		};
+		const bottom = {
+			x: bounds.x,
+			y: bounds.y + bounds.height - ry * 2,
+			width: bounds.width,
+			height: ry * 2
+		};
+		const body = {
+			x: bounds.x,
+			y: bounds.y + ry,
+			width: bounds.width,
+			height: Math.max(0, bounds.height - ry * 2)
+		};
+		if (point.x >= body.x && point.x <= body.x + body.width && point.y >= body.y && point.y <= body.y + body.height) return true;
+		return pointInEllipse(point, top) || pointInEllipse(point, bottom);
+	}
+};
+//#endregion
+//#region src/shapes/queue.ts
+/**
+* Horizontal pipe (sideways cylinder) — the ubiquitous message-queue silhouette.
+* End-cap radius is height-led so short wide queues keep readable openings.
+*/
+function queueRadii(width, height) {
+	const ry = height / 2;
+	return {
+		rx: Math.min(Math.max(height * .125, 7), width * .16, 13),
+		ry
+	};
+}
+/**
+* Pipe body + left-end rim (front opening), matching vertical cylinder conventions.
+*/
+function queuePaths(bounds) {
+	const { x, y, width, height } = bounds;
+	const { rx, ry } = queueRadii(width, height);
+	return {
+		body: [
+			`M ${x + rx} ${y}`,
+			`l ${width - 2 * rx} 0`,
+			`a ${rx} ${ry} 0 0 1 0 ${height}`,
+			`l ${-(width - 2 * rx)} 0`,
+			`a ${rx} ${ry} 0 0 1 0 ${-height}`,
+			`z`
+		].join(" "),
+		rim: `M ${x + rx} ${y} a ${rx} ${ry} 0 0 0 0 ${height}`
+	};
+}
+/**
+* Sampled silhouette for ports / ray hits (left ellipse → top → right ellipse → bottom).
+*/
+function queueSilhouettePolygon(bounds, samplesPerCap = 16) {
+	const { x, y, width, height } = bounds;
+	const { rx, ry } = queueRadii(width, height);
+	const cy = y + ry;
+	const pts = [];
+	for (let i = 0; i <= samplesPerCap; i++) {
+		const t = Math.PI / 2 + i / samplesPerCap * Math.PI;
+		pts.push({
+			x: x + rx + rx * Math.cos(t),
+			y: cy + ry * Math.sin(t)
+		});
+	}
+	for (let i = 0; i <= samplesPerCap; i++) {
+		const t = -Math.PI / 2 + i / samplesPerCap * Math.PI;
+		pts.push({
+			x: x + width - rx + rx * Math.cos(t),
+			y: cy + ry * Math.sin(t)
+		});
+	}
+	return pts;
+}
+const queueGeometry = {
+	id: "queue",
+	defaultSize: {
+		width: 160,
+		height: 64
+	},
+	minSize: {
+		width: 72,
+		height: 40
+	},
+	defaultPadding: {
+		top: 12,
+		right: 22,
+		bottom: 12,
+		left: 22
+	},
+	contentPolicy: {
+		align: "center",
+		maxLabelLines: 2,
+		iconPlacement: "leading"
+	},
+	getPath(bounds) {
+		const { body, rim } = queuePaths(bounds);
+		return {
+			d: body,
+			decorations: [{
+				d: rim,
+				role: "rim"
+			}]
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		const stroke = style.strokeWidth ?? 1.6;
+		const { rx } = queueRadii(bounds.width, bounds.height);
+		const sideReserve = Math.max(rx * 2, bounds.width * .12);
+		return {
+			x: bounds.x + sideReserve,
+			y: bounds.y + stroke + 6,
+			width: Math.max(0, bounds.width - sideReserve * 2),
+			height: Math.max(0, bounds.height - (stroke + 6) * 2)
+		};
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(queueGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		return projectSidePortOntoPolygon(port, bounds, queueSilhouettePolygon(bounds), intersectRayPolygon);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayPolygon(queueSilhouettePolygon(bounds), origin, direction);
+	},
+	containsPoint(bounds, point) {
+		const { rx } = queueRadii(bounds.width, bounds.height);
+		const left = {
+			x: bounds.x,
+			y: bounds.y,
+			width: rx * 2,
+			height: bounds.height
+		};
+		const right = {
+			x: bounds.x + bounds.width - rx * 2,
+			y: bounds.y,
+			width: rx * 2,
+			height: bounds.height
+		};
+		const body = {
+			x: bounds.x + rx,
+			y: bounds.y,
+			width: Math.max(0, bounds.width - rx * 2),
+			height: bounds.height
+		};
+		if (point.x >= body.x && point.x <= body.x + body.width && point.y >= body.y && point.y <= body.y + body.height) return true;
+		return pointInEllipse(point, left) || pointInEllipse(point, right);
+	}
+};
+//#endregion
+//#region src/shapes/stream.ts
+/** Corner radius for the stacked-log shell. */
+function streamCornerRadius(height, width) {
+	return Math.min(10, height * .18, width * .12);
+}
+/**
+* Partition y positions (absolute) for the stacked-log / Kafka-style silhouette.
+* Two interior rules divide the card into three record bands.
+*/
+function streamPartitionYs(bounds) {
+	const { y, height } = bounds;
+	return [y + height / 3, y + 2 * height / 3];
+}
+function streamShellPath(bounds) {
+	const { x, y, width, height } = bounds;
+	const r = streamCornerRadius(height, width);
+	return [
+		`M ${x + r} ${y}`,
+		`L ${x + width - r} ${y}`,
+		`A ${r} ${r} 0 0 1 ${x + width} ${y + r}`,
+		`L ${x + width} ${y + height - r}`,
+		`A ${r} ${r} 0 0 1 ${x + width - r} ${y + height}`,
+		`L ${x + r} ${y + height}`,
+		`A ${r} ${r} 0 0 1 ${x} ${y + height - r}`,
+		`L ${x} ${y + r}`,
+		`A ${r} ${r} 0 0 1 ${x + r} ${y}`,
+		`Z`
+	].join(" ");
+}
+/**
+* Short left-rail ticks — suggest stacked partitions without slicing through label/icon.
+*/
+function streamPartitionPaths(bounds) {
+	const { x, width, height } = bounds;
+	const tickLen = Math.min(14, Math.max(8, width * .1));
+	const insetX = Math.max(8, streamCornerRadius(height, width) * .75);
+	return streamPartitionYs(bounds).map((py) => `M ${x + insetX} ${py} L ${x + insetX + tickLen} ${py}`);
+}
+function streamPolygon(bounds) {
+	const { x, y, width, height } = bounds;
+	return [
+		{
+			x,
+			y
+		},
+		{
+			x: x + width,
+			y
+		},
+		{
+			x: x + width,
+			y: y + height
+		},
+		{
+			x,
+			y: y + height
+		}
+	];
+}
+/**
+* Stacked-log card — ubiquitous for streams, topics, and append-only partitions.
+* Outer shell holds the label; interior rules suggest record bands.
+*/
+const streamGeometry = {
+	id: "stream",
+	defaultSize: {
+		width: 160,
+		height: 72
+	},
+	minSize: {
+		width: 72,
+		height: 48
+	},
+	defaultPadding: {
+		top: 14,
+		right: 16,
+		bottom: 14,
+		left: 16
+	},
+	contentPolicy: {
+		align: "center",
+		maxLabelLines: 2,
+		iconPlacement: "leading"
+	},
+	getPath(bounds) {
+		return {
+			d: streamShellPath(bounds),
+			decorations: streamPartitionPaths(bounds).map((d) => ({
+				d,
+				role: "partition"
+			})),
+			polygon: streamPolygon(bounds)
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		const stroke = style.strokeWidth ?? 1.6;
+		const rail = Math.min(22, Math.max(16, bounds.width * .12));
+		return {
+			x: bounds.x + rail,
+			y: bounds.y + stroke + 8,
+			width: Math.max(0, bounds.width - rail - stroke - 10),
+			height: Math.max(0, bounds.height - (stroke + 8) * 2)
+		};
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(streamGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		return projectSidePortOntoPolygon(port, bounds, streamPolygon(bounds), intersectRayPolygon);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayPolygon(streamPolygon(bounds), origin, direction);
+	},
+	containsPoint(bounds, point) {
+		return pointInPolygon(point, streamPolygon(bounds));
+	}
+};
+//#endregion
+//#region src/shapes/ellipse.ts
+function createEllipseGeometry(id, contentRatio, opts = {}) {
+	const geometry = {
+		id,
+		defaultSize: opts.defaultSize ?? {
+			width: 120,
+			height: 80
+		},
+		minSize: {
+			width: 32,
+			height: 32
+		},
+		defaultPadding: {
+			top: 12,
+			right: 16,
+			bottom: 12,
+			left: 16
+		},
+		contentPolicy: {
+			align: "center",
+			maxLabelLines: id === "circle" ? 1 : 2,
+			preferExternalLabel: opts.preferExternalLabel ?? id === "circle",
+			iconPlacement: "centered"
+		},
+		getPath(bounds) {
+			const cx = bounds.x + bounds.width / 2;
+			const cy = bounds.y + bounds.height / 2;
+			const rx = bounds.width / 2;
+			const ry = bounds.height / 2;
+			return { d: [
+				`M ${cx - rx} ${cy}`,
+				`A ${rx} ${ry} 0 1 0 ${cx + rx} ${cy}`,
+				`A ${rx} ${ry} 0 1 0 ${cx - rx} ${cy}`,
+				`Z`
+			].join(" ") };
+		},
+		getContentBounds(bounds, style = {}) {
+			const stroke = style.strokeWidth ?? 1.6;
+			const content = centeredContentRect(bounds, contentRatio.w, contentRatio.h);
+			return {
+				x: content.x + stroke,
+				y: content.y + stroke,
+				width: Math.max(0, content.width - stroke * 2),
+				height: Math.max(0, content.height - stroke * 2)
+			};
+		},
+		getVisualBounds(bounds, style) {
+			return defaultVisualBounds(bounds, style);
+		},
+		getLayoutFootprint(bounds, context, style) {
+			return defaultLayoutFootprint(geometry, bounds, context, style);
+		},
+		getPortPosition(port, bounds) {
+			if (port.kind === "radial") {
+				const cx = bounds.x + bounds.width / 2;
+				const cy = bounds.y + bounds.height / 2;
+				const rad = port.angleDeg * Math.PI / 180;
+				return {
+					x: cx + Math.cos(rad) * (bounds.width / 2),
+					y: cy + Math.sin(rad) * (bounds.height / 2)
+				};
+			}
+			return projectSidePortOntoOutline(port, bounds, (direction) => intersectRayEllipse(bounds, {
+				x: bounds.x + bounds.width / 2,
+				y: bounds.y + bounds.height / 2
+			}, direction));
+		},
+		getPortNormal(port, bounds) {
+			if (port.kind === "radial") {
+				const rad = port.angleDeg * Math.PI / 180;
+				return {
+					x: Math.cos(rad),
+					y: Math.sin(rad)
+				};
+			}
+			return defaultPortNormal(port, bounds);
+		},
+		intersectRay(bounds, origin, direction) {
+			return intersectRayEllipse(bounds, origin, direction);
+		},
+		containsPoint(bounds, point) {
+			return pointInEllipse(point, bounds);
+		}
+	};
+	return geometry;
+}
+const ellipseGeometry = createEllipseGeometry("ellipse", {
+	w: .7,
+	h: .7
+});
+const circleGeometry = createEllipseGeometry("circle", {
+	w: .55,
+	h: .55
+}, {
+	preferExternalLabel: true,
+	defaultSize: {
+		width: 40,
+		height: 40
+	}
+});
+//#endregion
+//#region src/shapes/polygons.ts
+function parallelogramPolygon(bounds, skewRatio = .18, direction = "right") {
+	const skew = Math.min(bounds.width * skewRatio, bounds.width * .35);
+	const { x, y, width, height } = bounds;
+	if (direction === "right") return [
+		{
+			x: x + skew,
+			y
+		},
+		{
+			x: x + width,
+			y
+		},
+		{
+			x: x + width - skew,
+			y: y + height
+		},
+		{
+			x,
+			y: y + height
+		}
+	];
+	return [
+		{
+			x,
+			y
+		},
+		{
+			x: x + width - skew,
+			y
+		},
+		{
+			x: x + width,
+			y: y + height
+		},
+		{
+			x: x + skew,
+			y: y + height
+		}
+	];
+}
+function createParallelogramGeometry(id = "parallelogram", direction = "right") {
+	const geometry = {
+		id,
+		defaultSize: {
+			width: 160,
+			height: 64
+		},
+		minSize: {
+			width: 72,
+			height: 36
+		},
+		defaultPadding: {
+			top: 12,
+			right: 24,
+			bottom: 12,
+			left: 24
+		},
+		contentPolicy: {
+			align: "center",
+			maxLabelLines: 2,
+			iconPlacement: "none"
+		},
+		getPath(bounds) {
+			const polygon = parallelogramPolygon(bounds, .18, direction);
+			return {
+				d: polygonToPath(polygon),
+				polygon
+			};
+		},
+		getContentBounds(bounds, style = {}) {
+			const stroke = style.strokeWidth ?? 1.6;
+			const skew = Math.min(bounds.width * .18, bounds.width * .35);
+			return {
+				x: bounds.x + skew + stroke,
+				y: bounds.y + stroke + 4,
+				width: Math.max(0, bounds.width - skew * 2 - stroke * 2),
+				height: Math.max(0, bounds.height - (stroke + 4) * 2)
+			};
+		},
+		getVisualBounds(bounds, style) {
+			return defaultVisualBounds(bounds, style);
+		},
+		getLayoutFootprint(bounds, context, style) {
+			return defaultLayoutFootprint(geometry, bounds, context, style);
+		},
+		getPortPosition(port, bounds) {
+			return projectSidePortOntoPolygon(port, bounds, parallelogramPolygon(bounds, .18, direction), intersectRayPolygon);
+		},
+		getPortNormal(port, bounds) {
+			return defaultPortNormal(port, bounds);
+		},
+		intersectRay(bounds, origin, directionVec) {
+			return intersectRayPolygon(parallelogramPolygon(bounds, .18, direction), origin, directionVec);
+		},
+		containsPoint(bounds, point) {
+			return pointInPolygon(point, parallelogramPolygon(bounds, .18, direction));
+		}
+	};
+	return geometry;
+}
+const parallelogramGeometry = createParallelogramGeometry();
+function trapezoidPolygon(bounds, narrowTop = true, insetRatio = .16) {
+	const inset = Math.min(bounds.width * insetRatio, bounds.width * .3);
+	const { x, y, width, height } = bounds;
+	if (narrowTop) return [
+		{
+			x: x + inset,
+			y
+		},
+		{
+			x: x + width - inset,
+			y
+		},
+		{
+			x: x + width,
+			y: y + height
+		},
+		{
+			x,
+			y: y + height
+		}
+	];
+	return [
+		{
+			x,
+			y
+		},
+		{
+			x: x + width,
+			y
+		},
+		{
+			x: x + width - inset,
+			y: y + height
+		},
+		{
+			x: x + inset,
+			y: y + height
+		}
+	];
+}
+function createTrapezoidGeometry(id = "trapezoid", narrowTop = false) {
+	const geometry = {
+		id,
+		defaultSize: {
+			width: 160,
+			height: 64
+		},
+		minSize: {
+			width: 72,
+			height: 36
+		},
+		defaultPadding: {
+			top: 12,
+			right: 16,
+			bottom: 12,
+			left: 16
+		},
+		contentPolicy: {
+			align: "center",
+			maxLabelLines: 2,
+			iconPlacement: "none"
+		},
+		getPath(bounds) {
+			const polygon = trapezoidPolygon(bounds, narrowTop);
+			return {
+				d: polygonToPath(polygon),
+				polygon
+			};
+		},
+		getContentBounds(bounds, style = {}) {
+			const stroke = style.strokeWidth ?? 1.6;
+			const inset = Math.min(bounds.width * .16, bounds.width * .3);
+			return {
+				x: bounds.x + inset + stroke,
+				y: bounds.y + stroke + 4,
+				width: Math.max(0, bounds.width - inset * 2 - stroke * 2),
+				height: Math.max(0, bounds.height - (stroke + 4) * 2)
+			};
+		},
+		getVisualBounds(bounds, style) {
+			return defaultVisualBounds(bounds, style);
+		},
+		getLayoutFootprint(bounds, context, style) {
+			return defaultLayoutFootprint(geometry, bounds, context, style);
+		},
+		getPortPosition(port, bounds) {
+			return projectSidePortOntoPolygon(port, bounds, trapezoidPolygon(bounds, narrowTop), intersectRayPolygon);
+		},
+		getPortNormal(port, bounds) {
+			return defaultPortNormal(port, bounds);
+		},
+		intersectRay(bounds, origin, direction) {
+			return intersectRayPolygon(trapezoidPolygon(bounds, narrowTop), origin, direction);
+		},
+		containsPoint(bounds, point) {
+			return pointInPolygon(point, trapezoidPolygon(bounds, narrowTop));
+		}
+	};
+	return geometry;
+}
+/** Manual operation: wider top. */
+const trapezoidGeometry = createTrapezoidGeometry("trapezoid", false);
+function trianglePolygon(bounds) {
+	return [
+		{
+			x: bounds.x + bounds.width / 2,
+			y: bounds.y
+		},
+		{
+			x: bounds.x + bounds.width,
+			y: bounds.y + bounds.height
+		},
+		{
+			x: bounds.x,
+			y: bounds.y + bounds.height
+		}
+	];
+}
+const triangleGeometry = {
+	id: "triangle",
+	defaultSize: {
+		width: 72,
+		height: 64
+	},
+	minSize: {
+		width: 32,
+		height: 28
+	},
+	defaultPadding: {
+		top: 16,
+		right: 12,
+		bottom: 8,
+		left: 12
+	},
+	contentPolicy: {
+		align: "center",
+		maxLabelLines: 1,
+		preferExternalLabel: true,
+		iconPlacement: "centered"
+	},
+	clearSpaceBoost: 8,
+	getPath(bounds) {
+		const polygon = trianglePolygon(bounds);
+		return {
+			d: polygonToPath(polygon),
+			polygon
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		const stroke = style.strokeWidth ?? 1.6;
+		return centeredContentRect({
+			x: bounds.x + stroke,
+			y: bounds.y + bounds.height * .35,
+			width: Math.max(0, bounds.width - stroke * 2),
+			height: Math.max(0, bounds.height * .45 - stroke)
+		}, 1, 1);
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(triangleGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		return projectSidePortOntoPolygon(port, bounds, trianglePolygon(bounds), intersectRayPolygon);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayPolygon(trianglePolygon(bounds), origin, direction);
+	},
+	containsPoint(bounds, point) {
+		return pointInPolygon(point, trianglePolygon(bounds));
+	}
+};
+//#endregion
+//#region src/shapes/document.ts
+/**
+* Document: rectangle with a deterministic wavy bottom.
+* Ray tests and south ports use the same sampled wave polygon as the path.
+*/
+function documentPolygon(bounds, samples = 8) {
+	const { x, y, width, height } = bounds;
+	const waveAmp = Math.min(10, height * .12);
+	const bodyH = height - waveAmp;
+	const pts = [
+		{
+			x,
+			y
+		},
+		{
+			x: x + width,
+			y
+		},
+		{
+			x: x + width,
+			y: y + bodyH
+		}
+	];
+	for (let i = samples; i >= 0; i--) {
+		const t = i / samples;
+		const px = x + width * t;
+		const py = y + bodyH + Math.sin(t * Math.PI) * waveAmp;
+		pts.push({
+			x: px,
+			y: py
+		});
+	}
+	return pts;
+}
+const documentGeometry = {
+	id: "document",
+	defaultSize: {
+		width: 140,
+		height: 80
+	},
+	minSize: {
+		width: 64,
+		height: 48
+	},
+	defaultPadding: {
+		top: 14,
+		right: 16,
+		bottom: 20,
+		left: 16
+	},
+	contentPolicy: {
+		align: "start",
+		maxLabelLines: 2,
+		iconPlacement: "leading"
+	},
+	getPath(bounds) {
+		const polygon = documentPolygon(bounds);
+		return {
+			d: polygonToPath(polygon),
+			polygon
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		const stroke = style.strokeWidth ?? 1.6;
+		const waveAmp = Math.min(10, bounds.height * .12);
+		return {
+			x: bounds.x + stroke + 8,
+			y: bounds.y + stroke + 8,
+			width: Math.max(0, bounds.width - (stroke + 8) * 2),
+			height: Math.max(0, bounds.height - waveAmp - stroke * 2 - 16)
+		};
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(documentGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		return projectSidePortOntoPolygon(port, bounds, documentPolygon(bounds), intersectRayPolygon);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayPolygon(documentPolygon(bounds), origin, direction);
+	},
+	containsPoint(bounds, point) {
+		return pointInPolygon(point, documentPolygon(bounds));
+	}
+};
+/** Folded-corner note — rectangle with a clipped top-right fold. */
+function foldedCornerPath(bounds, fold = 14) {
+	const { x, y, width, height } = bounds;
+	const f = Math.min(fold, width * .25, height * .25);
+	return {
+		body: [
+			`M ${x} ${y}`,
+			`L ${x + width - f} ${y}`,
+			`L ${x + width} ${y + f}`,
+			`L ${x + width} ${y + height}`,
+			`L ${x} ${y + height}`,
+			`Z`
+		].join(" "),
+		foldLine: `M ${x + width - f} ${y} L ${x + width - f} ${y + f} L ${x + width} ${y + f}`
+	};
+}
+function foldedDocumentPolygon(bounds, fold = 14) {
+	const { x, y, width, height } = bounds;
+	const f = Math.min(fold, width * .25, height * .25);
+	return [
+		{
+			x,
+			y
+		},
+		{
+			x: x + width - f,
+			y
+		},
+		{
+			x: x + width,
+			y: y + f
+		},
+		{
+			x: x + width,
+			y: y + height
+		},
+		{
+			x,
+			y: y + height
+		}
+	];
+}
+const foldedDocumentGeometry = {
+	id: "folded-document",
+	defaultSize: {
+		width: 140,
+		height: 80
+	},
+	minSize: {
+		width: 64,
+		height: 48
+	},
+	defaultPadding: {
+		top: 14,
+		right: 18,
+		bottom: 14,
+		left: 14
+	},
+	contentPolicy: {
+		align: "start",
+		maxLabelLines: 3,
+		iconPlacement: "none"
+	},
+	getPath(bounds) {
+		const { body, foldLine } = foldedCornerPath(bounds);
+		return {
+			d: body,
+			decorations: [{
+				d: foldLine,
+				role: "fold"
+			}]
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		const stroke = style.strokeWidth ?? 1.6;
+		const fold = Math.min(14, bounds.width * .25);
+		return {
+			x: bounds.x + stroke + 8,
+			y: bounds.y + stroke + 8,
+			width: Math.max(0, bounds.width - fold - stroke * 2 - 12),
+			height: Math.max(0, bounds.height - (stroke + 8) * 2)
+		};
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(foldedDocumentGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		return projectSidePortOntoPolygon(port, bounds, foldedDocumentPolygon(bounds), intersectRayPolygon);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayPolygon(foldedDocumentPolygon(bounds), origin, direction);
+	},
+	containsPoint(bounds, point) {
+		return pointInPolygon(point, foldedDocumentPolygon(bounds));
+	}
+};
+//#endregion
+//#region src/shapes/cloud.ts
+/**
+* Material Design cloud scaled into bounds.
+* Flat base, soft lobes — proven silhouette (24×24 viewBox, content y∈[4,20]).
+*/
+const VB = {
+	x: 0,
+	y: 4,
+	w: 24,
+	h: 16
+};
+/** Intrinsic cloud aspect (viewBox content width / height). */
+const CLOUD_ASPECT = VB.w / VB.h;
+/**
+* Largest 3:2 rect centered in `bounds`. Non-uniform stretch turns lobes into a
+* sausage; letterbox so the silhouette stays cloud-shaped even if layout is tall.
+*/
+function fitCloudBounds(bounds) {
+	if (bounds.width / Math.max(bounds.height, 1e-6) >= CLOUD_ASPECT) {
+		const width = bounds.height * CLOUD_ASPECT;
+		return {
+			x: bounds.x + (bounds.width - width) / 2,
+			y: bounds.y,
+			width,
+			height: bounds.height
+		};
+	}
+	const height = bounds.width / CLOUD_ASPECT;
+	return {
+		x: bounds.x,
+		y: bounds.y + (bounds.height - height) / 2,
+		width: bounds.width,
+		height
+	};
+}
+function map(bounds, px, py) {
+	return {
+		x: bounds.x + (px - VB.x) / VB.w * bounds.width,
+		y: bounds.y + (py - VB.y) / VB.h * bounds.height
+	};
+}
+function cloudSegments(bounds) {
+	const fitted = fitCloudBounds(bounds);
+	const p = (x, y) => map(fitted, x, y);
+	return {
+		start: p(19.35, 10.04),
+		segs: [
+			{
+				type: "C",
+				c1: p(18.67, 6.59),
+				c2: p(15.64, 4),
+				end: p(12, 4)
+			},
+			{
+				type: "C",
+				c1: p(9.11, 4),
+				c2: p(6.6, 5.64),
+				end: p(5.35, 8.04)
+			},
+			{
+				type: "C",
+				c1: p(2.34, 8.36),
+				c2: p(0, 10.91),
+				end: p(0, 14)
+			},
+			{
+				type: "C",
+				c1: p(0, 17.31),
+				c2: p(2.69, 20),
+				end: p(6, 20)
+			},
+			{
+				type: "L",
+				end: p(19, 20)
+			},
+			{
+				type: "C",
+				c1: p(21.76, 20),
+				c2: p(24, 17.76),
+				end: p(24, 15)
+			},
+			{
+				type: "C",
+				c1: p(24, 12.36),
+				c2: p(21.95, 10.22),
+				end: p(19.35, 10.04)
+			}
+		]
+	};
+}
+function sampleCubic(p0, p1, p2, p3, steps) {
+	const pts = [];
+	for (let i = 1; i <= steps; i++) {
+		const t = i / steps;
+		const u = 1 - t;
+		pts.push({
+			x: u * u * u * p0.x + 3 * u * u * t * p1.x + 3 * u * t * t * p2.x + t * t * t * p3.x,
+			y: u * u * u * p0.y + 3 * u * u * t * p1.y + 3 * u * t * t * p2.y + t * t * t * p3.y
+		});
+	}
+	return pts;
+}
+/** Hit-test / port polygon matching the Material silhouette. */
+function cloudSamplePolygon(bounds, stepsPerCurve = 10) {
+	const { start, segs } = cloudSegments(bounds);
+	const pts = [start];
+	let cur = start;
+	for (const seg of segs) if (seg.type === "L") {
+		pts.push(seg.end);
+		cur = seg.end;
+	} else {
+		pts.push(...sampleCubic(cur, seg.c1, seg.c2, seg.end, stepsPerCurve));
+		cur = seg.end;
+	}
+	return pts;
+}
+/** Material cloud path scaled into the node box. */
+function cloudPath(bounds) {
+	const { start, segs } = cloudSegments(bounds);
+	let d = `M ${start.x} ${start.y}`;
+	for (const seg of segs) if (seg.type === "L") d += ` L ${seg.end.x} ${seg.end.y}`;
+	else d += ` C ${seg.c1.x} ${seg.c1.y}, ${seg.c2.x} ${seg.c2.y}, ${seg.end.x} ${seg.end.y}`;
+	return `${d} Z`;
+}
+const cloudGeometry = {
+	id: "cloud",
+	defaultSize: {
+		width: 160,
+		height: 100
+	},
+	minSize: {
+		width: 80,
+		height: 56
+	},
+	defaultPadding: {
+		top: 20,
+		right: 24,
+		bottom: 20,
+		left: 24
+	},
+	contentPolicy: {
+		align: "center",
+		maxLabelLines: 2,
+		preferExternalLabel: false,
+		iconPlacement: "centered"
+	},
+	getPath(bounds) {
+		return {
+			d: cloudPath(bounds),
+			polygon: cloudSamplePolygon(bounds)
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		const stroke = style.strokeWidth ?? 1.6;
+		const fitted = fitCloudBounds(bounds);
+		const content = centeredContentRect(fitted, .55, .42);
+		content.y = fitted.y + fitted.height * .38;
+		return {
+			x: content.x + stroke,
+			y: content.y + stroke,
+			width: Math.max(0, content.width - stroke * 2),
+			height: Math.max(0, content.height - stroke * 2)
+		};
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(cloudGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		return projectSidePortOntoPolygon(port, bounds, cloudSamplePolygon(bounds), intersectRayPolygon);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayPolygon(cloudSamplePolygon(bounds), origin, direction);
+	},
+	containsPoint(bounds, point) {
+		return pointInPolygon(point, cloudSamplePolygon(bounds));
+	}
+};
+//#endregion
+//#region src/shapes/person.ts
+/** Head sits above the torso; torso uses the full node width and holds content. */
+const HEAD_GAP = .18;
+const BODY_PAD_X = 12;
+const BODY_PAD_Y = 10;
+function personLayout(bounds, stroke = DEFAULT_STROKE_WIDTH) {
+	const { x, y, width, height } = bounds;
+	const inset = stroke + 1;
+	const bodyHalfW = Math.max(18, width / 2 - inset);
+	const headR = Math.max(10, Math.min(22, bodyHalfW * .38));
+	const headCy = y + headR + Math.max(3, inset);
+	const bodyTop = headCy + headR + Math.max(2, headR * HEAD_GAP);
+	const bodyBottom = y + height - inset;
+	const bodyH = Math.max(bodyBottom - bodyTop, headR * 2.2);
+	const bodyRx = Math.min(bodyHalfW, bodyH * .42);
+	const cx = x + width / 2;
+	return {
+		cx,
+		headR,
+		headCy,
+		bodyTop,
+		bodyBottom,
+		bodyHalfW,
+		bodyRx,
+		content: {
+			x: cx - bodyHalfW + BODY_PAD_X,
+			y: bodyTop + BODY_PAD_Y,
+			width: Math.max(0, bodyHalfW * 2 - BODY_PAD_X * 2),
+			height: Math.max(0, bodyBottom - bodyTop - BODY_PAD_Y * 2)
+		}
+	};
+}
+/** Port anchors: head (N), torso sides (E/W), feet (S). */
+function personPortAnchors(bounds) {
+	const { cx, headR, headCy, bodyTop, bodyBottom, bodyHalfW, bodyRx } = personLayout(bounds);
+	const ry = Math.min(bodyRx, (bodyBottom - bodyTop) / 2);
+	const shoulderY = bodyTop + ry + Math.max(2, (bodyBottom - bodyTop - 2 * ry) * .12);
+	return {
+		north: {
+			x: cx,
+			y: headCy - headR
+		},
+		east: {
+			x: cx + bodyHalfW,
+			y: shoulderY
+		},
+		west: {
+			x: cx - bodyHalfW,
+			y: shoulderY
+		},
+		south: {
+			x: cx,
+			y: bodyBottom
+		}
+	};
+}
+/** Closed silhouette for rays / multi-port projection (head arc + rounded torso). */
+function personSilhouettePolygon(bounds, headSamples = 12) {
+	const { cx, headR, headCy, bodyTop, bodyBottom, bodyHalfW, bodyRx } = personLayout(bounds);
+	const pts = [];
+	for (let i = 0; i <= headSamples; i++) {
+		const t = Math.PI - i / headSamples * Math.PI;
+		pts.push({
+			x: cx + headR * Math.cos(t),
+			y: headCy - headR * Math.sin(t)
+		});
+	}
+	const right = cx + bodyHalfW;
+	const left = cx - bodyHalfW;
+	const ry = Math.min(bodyRx, (bodyBottom - bodyTop) / 2);
+	pts.push({
+		x: right,
+		y: bodyTop + ry
+	});
+	pts.push({
+		x: right,
+		y: bodyBottom - ry
+	});
+	pts.push({
+		x: cx + bodyHalfW - ry * .15,
+		y: bodyBottom
+	});
+	pts.push({
+		x: cx,
+		y: bodyBottom
+	});
+	pts.push({
+		x: cx - bodyHalfW + ry * .15,
+		y: bodyBottom
+	});
+	pts.push({
+		x: left,
+		y: bodyBottom - ry
+	});
+	pts.push({
+		x: left,
+		y: bodyTop + ry
+	});
+	return pts;
+}
+/**
+* Person / actor — C4-style head + rounded torso.
+* The torso is the content box: it grows with label/subtitle width.
+*/
+function personPaths(bounds) {
+	const { cx, headR, headCy, bodyTop, bodyBottom, bodyHalfW, bodyRx } = personLayout(bounds);
+	const head = `M ${cx} ${headCy} m ${-headR} 0 a ${headR} ${headR} 0 1 0 ${headR * 2} 0 a ${headR} ${headR} 0 1 0 ${-headR * 2} 0`;
+	const left = cx - bodyHalfW;
+	const right = cx + bodyHalfW;
+	const ry = Math.min(bodyRx, (bodyBottom - bodyTop) / 2);
+	return {
+		head,
+		body: [
+			`M ${left + ry} ${bodyTop}`,
+			`H ${right - ry}`,
+			`A ${ry} ${ry} 0 0 1 ${right} ${bodyTop + ry}`,
+			`V ${bodyBottom - ry}`,
+			`A ${ry} ${ry} 0 0 1 ${right - ry} ${bodyBottom}`,
+			`H ${left + ry}`,
+			`A ${ry} ${ry} 0 0 1 ${left} ${bodyBottom - ry}`,
+			`V ${bodyTop + ry}`,
+			`A ${ry} ${ry} 0 0 1 ${left + ry} ${bodyTop}`,
+			`Z`
+		].join(" ")
+	};
+}
+/** Extra height above the torso content for head + neck (used by measure). */
+function personHeadStackHeight(bodyWidth) {
+	const bodyHalfW = Math.max(18, bodyWidth / 2 - 2);
+	const headR = Math.max(10, Math.min(22, bodyHalfW * .38));
+	return headR * 2 + Math.max(2, headR * HEAD_GAP) + 6;
+}
+const personGeometry = {
+	id: "person",
+	defaultSize: {
+		width: 120,
+		height: 140
+	},
+	minSize: {
+		width: 72,
+		height: 96
+	},
+	defaultPadding: {
+		top: 8,
+		right: 12,
+		bottom: 10,
+		left: 12
+	},
+	contentPolicy: {
+		align: "center",
+		maxLabelLines: 2,
+		preferExternalLabel: false,
+		iconPlacement: "above"
+	},
+	clearSpaceBoost: 4,
+	getPath(bounds) {
+		const { head, body } = personPaths(bounds);
+		return {
+			d: `${head} ${body}`,
+			decorations: [{
+				d: head,
+				role: "head"
+			}, {
+				d: body,
+				role: "body"
+			}]
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		return personLayout(bounds, style.strokeWidth ?? 1.6).content;
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(personGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		if (port.kind === "side" && (port.count ?? 1) <= 1) {
+			const anchors = personPortAnchors(bounds);
+			const side = port.side;
+			if (side === "north" || side === "east" || side === "south" || side === "west") return anchors[side];
+		}
+		return projectSidePortOntoPolygon(port, bounds, personSilhouettePolygon(bounds), intersectRayPolygon);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayPolygon(personSilhouettePolygon(bounds), origin, direction);
+	},
+	containsPoint(bounds, point) {
+		return pointInPolygon(point, personSilhouettePolygon(bounds));
+	}
+};
+const compartmentedRectangleGeometry = {
+	id: "table",
+	defaultSize: {
+		width: 240,
+		height: 160
+	},
+	minSize: {
+		width: 140,
+		height: 72
+	},
+	defaultPadding: {
+		top: 8,
+		right: 12,
+		bottom: 8,
+		left: 12
+	},
+	contentPolicy: {
+		align: "start",
+		maxLabelLines: 1,
+		iconPlacement: "none"
+	},
+	getPath(bounds) {
+		const { x, y, width, height } = bounds;
+		return {
+			d: `M ${x} ${y} H ${x + width} V ${y + height} H ${x} Z`,
+			polygon: rectPolygon(bounds)
+		};
+	},
+	getContentBounds(bounds, style = {}) {
+		const stroke = style.strokeWidth ?? 1.6;
+		return {
+			x: bounds.x + stroke + 8,
+			y: bounds.y + stroke + 8,
+			width: Math.max(0, bounds.width - (stroke + 8) * 2),
+			height: Math.max(0, bounds.height - (stroke + 8) * 2)
+		};
+	},
+	getVisualBounds(bounds, style) {
+		return defaultVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(compartmentedRectangleGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds) {
+		return defaultSidePortPosition(port, bounds);
+	},
+	getPortNormal(port, bounds) {
+		return defaultPortNormal(port, bounds);
+	},
+	intersectRay(bounds, origin, direction) {
+		return intersectRayRect(bounds, origin, direction);
+	},
+	containsPoint(bounds, point) {
+		return pointInPolygon(point, rectPolygon(bounds));
+	}
+};
+const boundaryGeometry = {
+	id: "boundary",
+	defaultSize: {
+		width: 320,
+		height: 220
+	},
+	minSize: {
+		width: 120,
+		height: 80
+	},
+	defaultPadding: {
+		top: 28,
+		right: 20,
+		bottom: 20,
+		left: 20
+	},
+	contentPolicy: {
+		align: "start",
+		maxLabelLines: 1,
+		iconPlacement: "none"
+	},
+	getPath(bounds) {
+		return compartmentedRectangleGeometry.getPath(bounds);
+	},
+	getContentBounds(bounds, style) {
+		return compartmentedRectangleGeometry.getContentBounds(bounds, style);
+	},
+	getVisualBounds(bounds, style) {
+		return compartmentedRectangleGeometry.getVisualBounds(bounds, style);
+	},
+	getLayoutFootprint(bounds, context, style) {
+		return defaultLayoutFootprint(boundaryGeometry, bounds, context, style);
+	},
+	getPortPosition(port, bounds, style) {
+		return compartmentedRectangleGeometry.getPortPosition(port, bounds, style);
+	},
+	getPortNormal(port, bounds, style) {
+		return compartmentedRectangleGeometry.getPortNormal(port, bounds, style);
+	},
+	intersectRay(bounds, origin, direction, style) {
+		return compartmentedRectangleGeometry.intersectRay(bounds, origin, direction, style);
+	},
+	containsPoint(bounds, point, style) {
+		return compartmentedRectangleGeometry.containsPoint(bounds, point, style);
+	}
+};
+//#endregion
+//#region src/shapes/index.ts
+/** All built-in geometries keyed by id. */
+const BUILTIN_GEOMETRIES = {
+	rectangle: rectangleGeometry,
+	rounded: roundedRectangleGeometry,
+	pill: pillGeometry,
+	diamond: diamondGeometry,
+	hexagon: hexagonGeometry,
+	queue: queueGeometry,
+	stream: streamGeometry,
+	cylinder: cylinderGeometry,
+	circle: circleGeometry,
+	ellipse: ellipseGeometry,
+	parallelogram: parallelogramGeometry,
+	trapezoid: trapezoidGeometry,
+	triangle: triangleGeometry,
+	document: documentGeometry,
+	"folded-document": foldedDocumentGeometry,
+	cloud: cloudGeometry,
+	person: personGeometry,
+	table: compartmentedRectangleGeometry,
+	boundary: boundaryGeometry
+};
+//#endregion
+//#region src/registry.ts
+const customShapes = /* @__PURE__ */ new Map();
+const customNodeTypes = /* @__PURE__ */ new Map();
+function definitionFromGeometry(geometry) {
+	return {
+		id: geometry.id,
+		geometry,
+		defaultSize: geometry.defaultSize ?? {
+			width: 140,
+			height: 72
+		},
+		minSize: geometry.minSize ?? {
+			width: 40,
+			height: 32
+		},
+		defaultPadding: geometry.defaultPadding ?? {
+			top: 14,
+			right: 16,
+			bottom: 14,
+			left: 16
+		},
+		supportedPortStrategies: [
+			"bbox-mid",
+			"distributed-sides",
+			"perimeter"
+		],
+		contentPolicy: geometry.contentPolicy ?? {
+			align: "center",
+			maxLabelLines: 2
+		}
+	};
+}
+/** Register a custom shape without changing the renderer core. */
+function registerShape(definition) {
+	customShapes.set(definition.id, definition);
+}
+function unregisterShape(id) {
+	customShapes.delete(id);
+}
+function getShapeDefinition(id) {
+	const normalized = normalizeShapeId$1(id);
+	const custom = customShapes.get(normalized) ?? customShapes.get(id);
+	if (custom) return custom;
+	if (normalized in BUILTIN_GEOMETRIES) return definitionFromGeometry(BUILTIN_GEOMETRIES[normalized]);
+}
+function getShapeGeometry(id) {
+	return getShapeDefinition(id)?.geometry;
+}
+/**
+* Resolve a shape id with fallback.
+* Unknown ids fall back to rounded rectangle (same as historic SVG default).
+*/
+function resolveShapeGeometry(id) {
+	if (id) {
+		const found = getShapeGeometry(normalizeShapeId$1(id));
+		if (found) return found;
+	}
+	return BUILTIN_GEOMETRIES.rounded;
+}
+function listRegisteredShapeIds() {
+	const builtins = Object.keys(BUILTIN_GEOMETRIES);
+	const customs = [...customShapes.keys()];
+	return [.../* @__PURE__ */ new Set([...builtins, ...customs])];
+}
+/** Map authored shape synonyms onto registry ids (delegates to core). */
+function normalizeShapeId(shape) {
+	return normalizeShapeId$1(shape);
+}
+/** Register or override a semantic node type → shape mapping. */
+function registerNodeType(definition) {
+	customNodeTypes.set(definition.id, {
+		...definition,
+		shapeId: normalizeShapeId$1(definition.shapeId)
+	});
+}
+function unregisterNodeType(id) {
+	customNodeTypes.delete(id);
+}
+function nodeTypeFromKindCatalog(id) {
+	const defaults = BUILTIN_KIND_CATALOG[id];
+	if (!defaults) return void 0;
+	return {
+		id,
+		shapeId: defaults.shape,
+		defaultIcon: defaults.icon,
+		defaultStyle: defaults.cssVars,
+		capabilities: defaults.capabilities,
+		subtitle: defaults.subtitle,
+		category: defaults.category
+	};
+}
+function getNodeTypeDefinition(id) {
+	return customNodeTypes.get(id) ?? nodeTypeFromKindCatalog(id);
+}
+/**
+* Resolve the geometry for a semantic kind (with optional shape override).
+* Kind defaults come from the DSL catalog; shape overrides win.
+*/
+function resolveNodeTypeGeometry(kind, shapeOverride) {
+	if (shapeOverride) return resolveShapeGeometry(shapeOverride);
+	return resolveShapeGeometry(getNodeTypeDefinition(kind)?.shapeId);
+}
+function listRegisteredNodeTypeIds() {
+	const builtins = Object.keys(BUILTIN_KIND_CATALOG);
+	const customs = [...customNodeTypes.keys()];
+	return [.../* @__PURE__ */ new Set([...builtins, ...customs])].sort();
+}
+//#endregion
+//#region src/measure.ts
+/**
+* Given a measured content size, find geometry bounds large enough that
+* getContentBounds() can contain it. Uses iterative refinement because
+* content insets are not always linear (cylinder caps, hex chamfers, …).
+*/
+function geometrySizeForContent(geometry, content, seed) {
+	let width = Math.max(content.width, seed?.width ?? content.width, geometry.minSize?.width ?? 0);
+	let height = Math.max(content.height, seed?.height ?? content.height, geometry.minSize?.height ?? 0);
+	for (let i = 0; i < 6; i++) {
+		const bounds = {
+			x: 0,
+			y: 0,
+			width,
+			height
+		};
+		const box = geometry.getContentBounds(bounds);
+		const needW = box.width > 0 ? content.width / box.width : 1;
+		const needH = box.height > 0 ? content.height / box.height : 1;
+		const nextW = Math.max(width * needW, geometry.minSize?.width ?? 0);
+		const nextH = Math.max(height * needH, geometry.minSize?.height ?? 0);
+		if (Math.abs(nextW - width) < .5 && Math.abs(nextH - height) < .5) {
+			width = nextW;
+			height = nextH;
+			break;
+		}
+		width = nextW;
+		height = nextH;
+	}
+	return {
+		width,
+		height
+	};
+}
+/** Relative content box (origin at geometry top-left) for MeasuredNode.contentBox. */
+function relativeContentBox(geometry, width, height) {
+	return geometry.getContentBounds({
+		x: 0,
+		y: 0,
+		width,
+		height
+	});
+}
+//#endregion
+//#region src/attach.ts
+/** Intersection of a ray with the shape perimeter; falls back via center ray, then center. */
+function attachPointOnPerimeter(input) {
+	const geometry = resolveShapeGeometry(normalizeShapeId(input.shapeId));
+	const hit = geometry.intersectRay(input.bounds, input.origin, input.direction, input.style);
+	if (hit) return hit;
+	const cx = input.bounds.x + input.bounds.width / 2;
+	const cy = input.bounds.y + input.bounds.height / 2;
+	return geometry.intersectRay(input.bounds, {
+		x: cx,
+		y: cy
+	}, input.direction, input.style) ?? {
+		x: cx,
+		y: cy
+	};
+}
+//#endregion
+export { BUILTIN_GEOMETRIES, CLEAR_SPACE_PRESETS, DEFAULT_STROKE_WIDTH, EDGE_LAUNCH_PRESETS, MIN_INTERACTION_TARGET, attachPointOnPerimeter, boundaryGeometry, buildNodeBoundsModel, centeredContentRect, circleGeometry, closedCatmullRomToPath, cloudGeometry, compartmentedRectangleGeometry, cylinderGeometry, cylinderPaths, cylinderRadii, cylinderSilhouettePolygon, defaultLayoutFootprint, defaultPortNormal, defaultSidePortPosition, defaultVisualBounds, diamondGeometry, diamondPointsString, diamondPolygon, distributedSidePort, documentGeometry, ellipseGeometry, expandRectInsets, foldedDocumentGeometry, geometrySizeForContent, getNodeTypeDefinition, getShapeDefinition, getShapeGeometry, hexagonGeometry, hexagonInset, hexagonPointsString, hexagonPolygon, insetRect, insets, intersectRayEllipse, intersectRayPolygon, intersectRayRect, listRegisteredNodeTypeIds, listRegisteredShapeIds, normalizeShapeId, normalizeVector, parallelogramGeometry, personGeometry, personHeadStackHeight, personPaths, personPortAnchors, personSilhouettePolygon, pillGeometry, pointInEllipse, pointInPolygon, polygonToPath, projectSidePortOntoOutline, projectSidePortOntoPolygon, queueGeometry, queuePaths, queueRadii, queueSilhouettePolygon, rectFromSize, rectPolygon, rectangleGeometry, registerNodeType, registerShape, relativeContentBox, resolveNodeTypeGeometry, resolveShapeGeometry, roundedRectangleGeometry, sideMidpoint, sideNormal, streamCornerRadius, streamGeometry, streamPartitionPaths, streamPartitionYs, streamShellPath, strokeOutset, trapezoidGeometry, triangleGeometry, uniformInsets, unionRects, unregisterNodeType, unregisterShape };
+
+//# sourceMappingURL=index.mjs.map