@pascal-app/nodes 0.1.1

package/dist/measurement/renderer.js

@@ -0,0 +1,285 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { measurementAngle, measurementArea, measurementDistance, measurementNormal, measurementPerimeter, measurementPrismVolume, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { buildMeasurementAngleArcPoints, formatAngleRadians, formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, measurementPolygonLabelAnchor, measurementPresentationColor, triangulateMeasurementPolygon, } from '@pascal-app/editor';
+import { OVERLAY_LAYER, useNodeEvents, useViewer } from '@pascal-app/viewer';
+import { Html } from '@react-three/drei';
+import { useFrame } from '@react-three/fiber';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { BufferGeometry, DoubleSide, Float32BufferAttribute, MathUtils, Quaternion, Vector3, } from 'three';
+import { LineBasicNodeMaterial, MeshBasicNodeMaterial } from 'three/webgpu';
+import { useShallow } from 'zustand/react/shallow';
+import { measurementDependencyIds, resolveMeasurementNode, } from './resolve';
+const MARKER_PLANE_NORMAL = new Vector3(0, 0, 1);
+function fallbackMarkerNormal(measurement, index) {
+    if (measurement.kind === 'area' ||
+        measurement.kind === 'perimeter' ||
+        measurement.kind === 'volume') {
+        return measurementNormal(measurement.base) ?? [0, 1, 0];
+    }
+    if (measurement.kind === 'angle') {
+        const [start, vertex, end] = measurement.points;
+        const normal = new Vector3(...start)
+            .sub(new Vector3(...vertex))
+            .cross(new Vector3(...end).sub(new Vector3(...vertex)));
+        return normal.lengthSq() > 1e-12 ? normal.normalize().toArray() : [0, 1, 0];
+    }
+    const [start, end] = measurement.points;
+    if (Math.abs(start[1]) < 0.05 && Math.abs(end[1]) < 0.05)
+        return [0, 1, 0];
+    const direction = new Vector3(...end).sub(new Vector3(...start)).normalize();
+    const horizontalNormal = direction.cross(new Vector3(0, 1, 0));
+    if (horizontalNormal.lengthSq() > 1e-12) {
+        const normal = horizontalNormal.normalize();
+        if (index > 0)
+            normal.negate();
+        return normal.toArray();
+    }
+    return [0, 0, 1];
+}
+function SurfaceContactMarker({ color, normal, point, }) {
+    const ref = useRef(null);
+    const worldPosition = useMemo(() => new Vector3(), []);
+    const cameraSpacePosition = useMemo(() => new Vector3(), []);
+    const rotation = useMemo(() => {
+        const resolvedNormal = new Vector3(...normal);
+        if (resolvedNormal.lengthSq() <= 1e-12)
+            resolvedNormal.copy(MARKER_PLANE_NORMAL);
+        return new Quaternion().setFromUnitVectors(MARKER_PLANE_NORMAL, resolvedNormal.normalize());
+    }, [normal]);
+    const materials = useMemo(() => ({
+        halo: new MeshBasicNodeMaterial({
+            color: '#f8fafc',
+            depthTest: true,
+            depthWrite: false,
+            opacity: 0.92,
+            polygonOffset: true,
+            polygonOffsetFactor: -2,
+            polygonOffsetUnits: -2,
+            side: DoubleSide,
+            transparent: true,
+        }),
+        target: new MeshBasicNodeMaterial({
+            color,
+            depthTest: true,
+            depthWrite: false,
+            polygonOffset: true,
+            polygonOffsetFactor: -3,
+            polygonOffsetUnits: -3,
+            side: DoubleSide,
+        }),
+    }), [color]);
+    useEffect(() => () => {
+        materials.halo.dispose();
+        materials.target.dispose();
+    }, [materials]);
+    useFrame(({ camera, size }) => {
+        const group = ref.current;
+        if (!group)
+            return;
+        group.getWorldPosition(worldPosition);
+        let worldUnitsPerPixel = 0.01;
+        if (camera.isPerspectiveCamera) {
+            const perspective = camera;
+            const depth = Math.abs(cameraSpacePosition.copy(worldPosition).applyMatrix4(perspective.matrixWorldInverse).z);
+            worldUnitsPerPixel =
+                (2 * depth * Math.tan(MathUtils.degToRad(perspective.getEffectiveFOV() * 0.5))) /
+                    Math.max(size.height, 1);
+        }
+        else if (camera.isOrthographicCamera) {
+            const orthographic = camera;
+            worldUnitsPerPixel =
+                (orthographic.top - orthographic.bottom) / Math.max(orthographic.zoom * size.height, 1);
+        }
+        const scale = worldUnitsPerPixel * 7;
+        if (Number.isFinite(scale))
+            group.scale.setScalar(MathUtils.clamp(scale, 0.002, 0.24));
+    });
+    return (_jsxs("group", { position: point, quaternion: rotation, ref: ref, children: [_jsx("mesh", { layers: OVERLAY_LAYER, material: materials.halo, renderOrder: 1002, children: _jsx("ringGeometry", { args: [0.48, 1, 40] }) }), _jsx("mesh", { layers: OVERLAY_LAYER, material: materials.target, renderOrder: 1003, children: _jsx("ringGeometry", { args: [0.62, 0.86, 40] }) })] }));
+}
+const add = (point, offset) => [
+    point[0] + offset[0],
+    point[1] + offset[1],
+    point[2] + offset[2],
+];
+const midpoint = (start, end) => [
+    (start[0] + end[0]) / 2,
+    (start[1] + end[1]) / 2,
+    (start[2] + end[2]) / 2,
+];
+function buildFillGeometry(measurement) {
+    if (measurement.kind === 'distance' ||
+        measurement.kind === 'angle' ||
+        measurement.kind === 'perimeter') {
+        return null;
+    }
+    const triangles = triangulateMeasurementPolygon(measurement.base);
+    if (triangles.length === 0)
+        return null;
+    const top = measurement.kind === 'volume'
+        ? measurement.base.map((point) => add(point, measurement.extrusion))
+        : [];
+    const points = measurement.kind === 'volume' ? [...measurement.base, ...top] : measurement.base;
+    const indices = [];
+    for (const triangle of triangles) {
+        indices.push(triangle[0], triangle[1], triangle[2]);
+        if (measurement.kind === 'volume') {
+            const offset = measurement.base.length;
+            indices.push(triangle[0] + offset, triangle[1] + offset, triangle[2] + offset);
+        }
+    }
+    if (measurement.kind === 'volume') {
+        const offset = measurement.base.length;
+        for (let index = 0; index < offset; index++) {
+            const next = (index + 1) % offset;
+            indices.push(index, next, next + offset, index, next + offset, index + offset);
+        }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(points.flat(), 3));
+    geometry.setIndex(indices);
+    geometry.computeVertexNormals();
+    return geometry;
+}
+function buildRenderData(measurement) {
+    const linePositions = [];
+    const pushSegment = (start, end) => {
+        linePositions.push(...start, ...end);
+    };
+    let markerPoints;
+    let labelPosition;
+    if (measurement.kind === 'distance') {
+        const [start, end] = measurement.points;
+        pushSegment(start, end);
+        markerPoints = [start, end];
+        labelPosition = midpoint(start, end);
+    }
+    else if (measurement.kind === 'angle') {
+        const [start, vertex, end] = measurement.points;
+        pushSegment(start, vertex);
+        pushSegment(vertex, end);
+        const angleArc = buildMeasurementAngleArcPoints(start, vertex, end);
+        for (let index = 1; index < angleArc.length; index++) {
+            pushSegment(angleArc[index - 1], angleArc[index]);
+        }
+        markerPoints = [start, vertex, end];
+        labelPosition = angleArc[Math.floor(angleArc.length / 2)] ?? vertex;
+    }
+    else if (measurement.kind === 'area' || measurement.kind === 'perimeter') {
+        for (let index = 0; index < measurement.base.length; index++) {
+            pushSegment(measurement.base[index], measurement.base[(index + 1) % measurement.base.length]);
+        }
+        markerPoints = measurement.base;
+        labelPosition = measurementPolygonLabelAnchor(measurement.base) ?? measurement.base[0];
+    }
+    else {
+        const top = measurement.base.map((point) => add(point, measurement.extrusion));
+        for (let index = 0; index < measurement.base.length; index++) {
+            const next = (index + 1) % measurement.base.length;
+            pushSegment(measurement.base[index], measurement.base[next]);
+            pushSegment(top[index], top[next]);
+            pushSegment(measurement.base[index], top[index]);
+        }
+        markerPoints = [...measurement.base, ...top];
+        const centroid = measurementPolygonLabelAnchor(measurement.base) ?? measurement.base[0];
+        labelPosition = add(centroid, [
+            measurement.extrusion[0] / 2,
+            measurement.extrusion[1] / 2,
+            measurement.extrusion[2] / 2,
+        ]);
+    }
+    const lineGeometry = new BufferGeometry();
+    lineGeometry.setAttribute('position', new Float32BufferAttribute(linePositions, 3));
+    return {
+        fillGeometry: buildFillGeometry(measurement),
+        labelPosition,
+        lineGeometry,
+        markerPoints,
+    };
+}
+function formatMeasurement(measurement, unit) {
+    if (measurement.kind === 'distance') {
+        return formatLinearMeasurement(measurementDistance(...measurement.points), unit);
+    }
+    if (measurement.kind === 'angle') {
+        return formatAngleRadians(measurementAngle(...measurement.points));
+    }
+    if (measurement.kind === 'area') {
+        return `A ${formatAreaLabel(measurementArea(measurement.base), unit)}`;
+    }
+    if (measurement.kind === 'perimeter') {
+        return `P ${formatLinearMeasurement(measurementPerimeter(measurement.base), unit)}`;
+    }
+    return `V ${formatVolumeLabel(measurementPrismVolume(measurement.base, measurement.extrusion), unit)}`;
+}
+export function areMeasurementAncestorsVisible(object) {
+    let ancestor = object?.parent ?? null;
+    while (ancestor) {
+        if (!ancestor.visible)
+            return false;
+        ancestor = ancestor.parent;
+    }
+    return true;
+}
+export const MeasurementRenderer = ({ node }) => {
+    const ref = useRef(null);
+    const ancestorVisibilityRef = useRef(true);
+    const [ancestorsVisible, setAncestorsVisible] = useState(true);
+    useRegistry(node.id, 'measurement', ref);
+    const handlers = useNodeEvents(node, 'measurement');
+    const showMeasurements = useViewer((state) => state.showMeasurements);
+    const unit = useViewer((state) => state.unit);
+    const active = useViewer((state) => state.hoveredId === node.id || state.selection.selectedIds.some((id) => id === node.id));
+    const ownOverride = useLiveNodeOverrides((state) => state.overrides.get(node.id));
+    const effectiveNode = useMemo(() => (ownOverride ? { ...node, ...ownOverride } : node), [node, ownOverride]);
+    const dependencyIds = measurementDependencyIds(effectiveNode.measurement, (id) => useScene.getState().nodes[id]);
+    useScene(useShallow((state) => dependencyIds.map((id) => state.nodes[id])));
+    useLiveNodeOverrides(useShallow((state) => dependencyIds.map((id) => state.overrides.get(id))));
+    const resolved = resolveMeasurementNode(effectiveNode, (id) => {
+        const referencedNode = useScene.getState().nodes[id];
+        if (!referencedNode)
+            return undefined;
+        const liveOverride = useLiveNodeOverrides.getState().overrides.get(id);
+        return liveOverride ? { ...referencedNode, ...liveOverride } : referencedNode;
+    });
+    const data = buildRenderData(resolved.payload);
+    const label = useMemo(() => {
+        const value = formatMeasurement(resolved.payload, unit);
+        return resolved.dangling.length > 0 ? `Unlinked · ${value}` : value;
+    }, [resolved, unit]);
+    const color = measurementPresentationColor(resolved.dangling.length > 0, active);
+    const lineMaterial = useMemo(() => new LineBasicNodeMaterial({
+        color,
+        linewidth: 2,
+        depthTest: false,
+        depthWrite: false,
+    }), [color]);
+    const fillMaterial = useMemo(() => new MeshBasicNodeMaterial({
+        color,
+        transparent: true,
+        opacity: 0.12,
+        side: DoubleSide,
+        depthTest: false,
+        depthWrite: false,
+    }), [color]);
+    useEffect(() => () => {
+        data.fillGeometry?.dispose();
+        data.lineGeometry.dispose();
+    }, [data]);
+    useEffect(() => () => {
+        lineMaterial.dispose();
+        fillMaterial.dispose();
+    }, [fillMaterial, lineMaterial]);
+    useFrame(() => {
+        const visible = areMeasurementAncestorsVisible(ref.current);
+        if (visible === ancestorVisibilityRef.current)
+            return;
+        ancestorVisibilityRef.current = visible;
+        setAncestorsVisible(visible);
+    });
+    const shouldShow = showMeasurements && effectiveNode.visible !== false && ancestorsVisible;
+    return (_jsx("group", { ref: ref, ...handlers, userData: { labelPosition: data.labelPosition }, children: shouldShow && (_jsxs(_Fragment, { children: [data.fillGeometry && (_jsx("mesh", { frustumCulled: false, geometry: data.fillGeometry, layers: OVERLAY_LAYER, material: fillMaterial, renderOrder: 1000, userData: { excludeFromBvh: true } })), _jsx("lineSegments", { frustumCulled: false, geometry: data.lineGeometry, layers: OVERLAY_LAYER, material: lineMaterial, renderOrder: 1001 }), data.markerPoints.map((point, index) => (_jsx(SurfaceContactMarker, { color: color, normal: resolved.anchorNormals[index] ?? fallbackMarkerNormal(resolved.payload, index), point: point }, `${point.join(':')}:${index}`))), _jsx(Html, { center: true, position: data.labelPosition, style: { pointerEvents: 'none' }, zIndexRange: [30, 0], children: _jsx("div", { className: `whitespace-nowrap font-medium text-base text-white ${effectiveNode.measurement.kind === 'distance' ? '-translate-y-3' : ''}`, style: {
+                            textShadow: `-1px -1px 0 ${color}, 1px -1px 0 ${color}, -1px 1px 0 ${color}, 1px 1px 0 ${color}`,
+                        }, children: label }) })] })) }));
+};
+export default MeasurementRenderer;

package/dist/measurement/resolve.d.ts

@@ -0,0 +1,42 @@
+import { type AnyNode, type AnyNodeId, type MeasurementAnchor, type MeasurementFeature, type MeasurementFeatureReference, type MeasurementNode, type MeasurementPayload, type MeasurementPoint, remapMeasurementReferences } from '@pascal-app/core';
+export type ResolvedMeasurementPayload = {
+    kind: 'distance';
+    points: [MeasurementPoint, MeasurementPoint];
+} | {
+    kind: 'angle';
+    points: [MeasurementPoint, MeasurementPoint, MeasurementPoint];
+} | {
+    kind: 'area';
+    base: MeasurementPoint[];
+} | {
+    kind: 'perimeter';
+    base: MeasurementPoint[];
+} | {
+    kind: 'volume';
+    base: MeasurementPoint[];
+    extrusion: MeasurementPoint;
+};
+export type ResolvedMeasurement = {
+    payload: ResolvedMeasurementPayload;
+    dangling: MeasurementFeatureReference[];
+    dependencies: AnyNodeId[];
+    anchorNormals: Array<MeasurementPoint | null>;
+};
+type NodeResolver = (id: AnyNodeId) => AnyNode | undefined;
+export type MeasurementFeatureMatch = {
+    feature: MeasurementFeature;
+    point: MeasurementPoint;
+    t: number;
+    parameters: Record<string, string | number | boolean>;
+    distance: number;
+};
+export declare function measurementFeaturesForNode(node: AnyNode, resolve: NodeResolver): MeasurementFeature[];
+export declare function matchMeasurementFeatureForNode(node: AnyNode, resolve: NodeResolver, point: MeasurementPoint, maxDistance: number): MeasurementFeatureMatch | null;
+export declare function closestMeasurementFeature(features: readonly MeasurementFeature[], point: MeasurementPoint, maxDistance: number): MeasurementFeatureMatch | null;
+export declare function measurementFeaturePoint(feature: MeasurementFeature, reference: MeasurementFeatureReference): MeasurementPoint | null;
+export declare function measurementDependencyIds(measurement: MeasurementPayload, resolve?: NodeResolver): AnyNodeId[];
+export declare function resolveMeasurementNode(node: Pick<MeasurementNode, 'measurement'>, resolve: NodeResolver): ResolvedMeasurement;
+export declare function detachMeasurementPayload(node: Pick<MeasurementNode, 'measurement'>, resolve: NodeResolver): MeasurementPayload;
+export declare function freeMeasurementPoint(anchor: MeasurementAnchor): MeasurementPoint;
+export { remapMeasurementReferences };
+//# sourceMappingURL=resolve.d.ts.map

package/dist/measurement/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/measurement/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EAGrB,0BAA0B,EAC3B,MAAM,kBAAkB,CAAA;AAEzB,MAAM,MAAM,0BAA0B,GAClC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAA;CAAE,GAClE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,gBAAgB,CAAC,CAAA;CAAE,GACjF;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,gBAAgB,EAAE,CAAC;IAAC,SAAS,EAAE,gBAAgB,CAAA;CAAE,CAAA;AAE7E,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,0BAA0B,CAAA;IACnC,QAAQ,EAAE,2BAA2B,EAAE,CAAA;IACvC,YAAY,EAAE,SAAS,EAAE,CAAA;IACzB,aAAa,EAAE,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAA;CAC9C,CAAA;AAED,KAAK,YAAY,GAAG,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,GAAG,SAAS,CAAA;AAE1D,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,kBAAkB,CAAA;IAC3B,KAAK,EAAE,gBAAgB,CAAA;IACvB,CAAC,EAAE,MAAM,CAAA;IACT,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAA;IACrD,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAwBD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,wBAG9E;AAED,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,gBAAgB,EACvB,WAAW,EAAE,MAAM,GAClB,uBAAuB,GAAG,IAAI,CA2BhC;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,KAAK,EAAE,gBAAgB,EACvB,WAAW,EAAE,MAAM,GAClB,uBAAuB,GAAG,IAAI,CAahC;AAoCD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,2BAA2B,GACrC,gBAAgB,GAAG,IAAI,CAazB;AAqCD,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,kBAAkB,EAC/B,OAAO,CAAC,EAAE,YAAY,GACrB,SAAS,EAAE,CAUb;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,aAAa,CAAC,EAC1C,OAAO,EAAE,YAAY,GACpB,mBAAmB,CAkDrB;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,aAAa,CAAC,EAC1C,OAAO,EAAE,YAAY,GACpB,kBAAkB,CAEpB;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG,gBAAgB,CAEhF;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAA"}

package/dist/measurement/resolve.js

@@ -0,0 +1,207 @@
+import { closestMeasurementFeatureBinding, measurementAnchorFallback, nodeRegistry, remapMeasurementReferences, } from '@pascal-app/core';
+function childIds(node) {
+    return 'children' in node && Array.isArray(node.children) ? node.children : [];
+}
+function geometryContext(node, resolve) {
+    const parent = node.parentId ? (resolve(node.parentId) ?? null) : null;
+    const children = childIds(node)
+        .map(resolve)
+        .filter((child) => child !== undefined);
+    const siblings = parent
+        ? childIds(parent)
+            .map(resolve)
+            .filter((sibling) => sibling !== undefined && sibling.type === node.type)
+        : [];
+    const contextResolve = (id) => resolve(id);
+    return { resolve: contextResolve, parent, children, siblings };
+}
+export function measurementFeaturesForNode(node, resolve) {
+    const contribution = nodeRegistry.get(node.type)?.measurement;
+    return contribution ? contribution.features(node, geometryContext(node, resolve)) : [];
+}
+export function matchMeasurementFeatureForNode(node, resolve, point, maxDistance) {
+    const contribution = nodeRegistry.get(node.type)?.measurement;
+    if (!contribution)
+        return null;
+    const context = geometryContext(node, resolve);
+    const custom = contribution.match?.(node, context, point, maxDistance);
+    if (custom) {
+        const reference = {
+            nodeId: node.id,
+            featureId: custom.featureId,
+            parameters: custom.parameters,
+        };
+        const feature = contribution.resolve?.(node, context, reference) ??
+            contribution.features(node, context).find((candidate) => candidate.id === custom.featureId) ??
+            null;
+        if (feature) {
+            const t = typeof custom.parameters?.t === 'number' ? custom.parameters.t : 0.5;
+            return {
+                feature,
+                point: custom.point,
+                t,
+                parameters: custom.parameters ?? { t },
+                distance: custom.distance,
+            };
+        }
+    }
+    return closestMeasurementFeature(contribution.features(node, context), point, maxDistance);
+}
+export function closestMeasurementFeature(features, point, maxDistance) {
+    const binding = closestMeasurementFeatureBinding(features, point, maxDistance);
+    if (!binding)
+        return null;
+    const feature = features.find((candidate) => candidate.id === binding.featureId);
+    if (!feature)
+        return null;
+    const t = typeof binding.parameters?.t === 'number' ? binding.parameters.t : 0.5;
+    return {
+        feature,
+        point: binding.point,
+        t,
+        parameters: binding.parameters ?? { t },
+        distance: binding.distance,
+    };
+}
+function pointOnPath(points, t, closed) {
+    if (points.length === 0)
+        return null;
+    if (points.length === 1)
+        return points[0];
+    const segmentCount = closed ? points.length : points.length - 1;
+    const lengths = [];
+    let total = 0;
+    for (let index = 0; index < segmentCount; index++) {
+        const start = points[index];
+        const end = points[(index + 1) % points.length];
+        const length = Math.hypot(end[0] - start[0], end[1] - start[1], end[2] - start[2]);
+        lengths.push(length);
+        total += length;
+    }
+    if (total <= 1e-9)
+        return points[0];
+    let remaining = Math.max(0, Math.min(1, t)) * total;
+    for (let index = 0; index < segmentCount; index++) {
+        const length = lengths[index];
+        if (remaining <= length || index === segmentCount - 1) {
+            const start = points[index];
+            const end = points[(index + 1) % points.length];
+            const localT = length <= 1e-9 ? 0 : remaining / length;
+            return [
+                start[0] + (end[0] - start[0]) * localT,
+                start[1] + (end[1] - start[1]) * localT,
+                start[2] + (end[2] - start[2]) * localT,
+            ];
+        }
+        remaining -= length;
+    }
+    return points[points.length - 1];
+}
+export function measurementFeaturePoint(feature, reference) {
+    const tValue = reference.parameters?.t;
+    const t = typeof tValue === 'number' ? tValue : 0.5;
+    switch (feature.geometry.kind) {
+        case 'point':
+            return feature.geometry.point;
+        case 'segment':
+            return pointOnPath([feature.geometry.start, feature.geometry.end], t, false);
+        case 'path':
+            return pointOnPath(feature.geometry.points, t, feature.geometry.closed === true);
+        case 'polygon':
+            return pointOnPath(feature.geometry.points, t, true);
+    }
+}
+function resolveAnchor(anchor, resolve) {
+    if (Array.isArray(anchor))
+        return { point: anchor, normal: null, dangling: null };
+    const referencedNode = resolve(anchor.reference.nodeId);
+    const contribution = referencedNode
+        ? nodeRegistry.get(referencedNode.type)?.measurement
+        : undefined;
+    if (!referencedNode || !contribution) {
+        return { point: anchor.fallback, normal: null, dangling: anchor.reference };
+    }
+    const context = geometryContext(referencedNode, resolve);
+    const feature = contribution.resolve?.(referencedNode, context, anchor.reference) ??
+        contribution
+            .features(referencedNode, context)
+            .find((candidate) => candidate.id === anchor.reference.featureId) ??
+        null;
+    const point = feature ? measurementFeaturePoint(feature, anchor.reference) : null;
+    return point
+        ? { point, normal: feature?.normal ?? null, dangling: null }
+        : { point: anchor.fallback, normal: null, dangling: anchor.reference };
+}
+function anchorsFor(payload) {
+    return payload.kind === 'distance' || payload.kind === 'angle' ? payload.points : payload.base;
+}
+export function measurementDependencyIds(measurement, resolve) {
+    const ids = new Set();
+    for (const anchor of anchorsFor(measurement)) {
+        if (Array.isArray(anchor))
+            continue;
+        const nodeId = anchor.reference.nodeId;
+        ids.add(nodeId);
+        const node = resolve?.(nodeId);
+        if (node?.parentId)
+            ids.add(node.parentId);
+    }
+    return [...ids];
+}
+export function resolveMeasurementNode(node, resolve) {
+    const dangling = [];
+    const anchorNormals = [];
+    const point = (anchor) => {
+        const result = resolveAnchor(anchor, resolve);
+        if (result.dangling)
+            dangling.push(result.dangling);
+        anchorNormals.push(result.normal);
+        return result.point;
+    };
+    const measurement = node.measurement;
+    let payload;
+    switch (measurement.kind) {
+        case 'distance':
+            payload = {
+                kind: 'distance',
+                points: [point(measurement.points[0]), point(measurement.points[1])],
+            };
+            break;
+        case 'angle':
+            payload = {
+                kind: 'angle',
+                points: [
+                    point(measurement.points[0]),
+                    point(measurement.points[1]),
+                    point(measurement.points[2]),
+                ],
+            };
+            break;
+        case 'area':
+            payload = { kind: 'area', base: measurement.base.map(point) };
+            break;
+        case 'perimeter':
+            payload = { kind: 'perimeter', base: measurement.base.map(point) };
+            break;
+        case 'volume':
+            payload = {
+                kind: 'volume',
+                base: measurement.base.map(point),
+                extrusion: measurement.extrusion,
+            };
+            break;
+    }
+    return {
+        payload,
+        dangling,
+        dependencies: measurementDependencyIds(measurement, resolve),
+        anchorNormals,
+    };
+}
+export function detachMeasurementPayload(node, resolve) {
+    return resolveMeasurementNode(node, resolve).payload;
+}
+export function freeMeasurementPoint(anchor) {
+    return measurementAnchorFallback(anchor);
+}
+export { remapMeasurementReferences };

package/dist/measurement/schema.d.ts

@@ -0,0 +1,2 @@
+export { MeasurementNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/measurement/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/measurement/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/measurement/schema.js

@@ -0,0 +1 @@
+export { MeasurementNode } from '@pascal-app/core';

package/dist/measurement/selection.d.ts

@@ -0,0 +1,3 @@
+declare const MeasurementSelectionAffordance: () => import("react").JSX.Element | null;
+export default MeasurementSelectionAffordance;
+//# sourceMappingURL=selection.d.ts.map

package/dist/measurement/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/measurement/selection.tsx"],"names":[],"mappings":"AA+XA,QAAA,MAAM,8BAA8B,0CAiCnC,CAAA;AAED,eAAe,8BAA8B,CAAA"}