@pascal-app/core 0.5.0 → 0.6.0

package/dist/systems/stair/stair-system.js

@@ -1,13 +1,19 @@
 import { useFrame } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
 import { spatialGridManager } from '../../hooks/spatial-grid/spatial-grid-manager';
 import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
 import useScene from '../../store/use-scene';
+import { syncAutoStairOpenings } from './stair-opening-sync';
 const pendingStairUpdates = new Set();
 const MAX_STAIRS_PER_FRAME = 2;
 const MAX_SEGMENTS_PER_FRAME = 4;
+const STAIR_TREAD_MATERIAL_INDEX = 0;
+const STAIR_SIDE_MATERIAL_INDEX = 1;
+const _uvPosition = new THREE.Vector3();
+const _uvNormal = new THREE.Vector3();
 // ============================================================================
 // STAIR SYSTEM
 // ============================================================================
@@ -15,6 +21,26 @@ export const StairSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
     const rootNodeIds = useScene((state) => state.rootNodeIds);
+    const syncingAutoOpeningsRef = useRef(false);
+    useEffect(() => {
+        const applyUpdates = (updates) => {
+            if (updates.length === 0)
+                return;
+            syncingAutoOpeningsRef.current = true;
+            useScene.getState().updateNodes(updates);
+            queueMicrotask(() => {
+                syncingAutoOpeningsRef.current = false;
+            });
+        };
+        applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
+        return useScene.subscribe((state, prevState) => {
+            if (syncingAutoOpeningsRef.current)
+                return;
+            if (state.nodes === prevState.nodes)
+                return;
+            applyUpdates(syncAutoStairOpenings(state.nodes));
+        });
+    }, []);
     useFrame(() => {
         if (rootNodeIds.length === 0) {
             pendingStairUpdates.clear();
@@ -159,7 +185,7 @@ function generateStairSegmentGeometry(segment, absoluteHeight) {
         }
     }
     shape.lineTo(0, 0);
-    const geometry = new THREE.ExtrudeGeometry(shape, {
+    const extrudedGeometry = new THREE.ExtrudeGeometry(shape, {
         steps: 1,
         depth: width,
         bevelEnabled: false,
@@ -169,13 +195,21 @@ function generateStairSegmentGeometry(segment, absoluteHeight) {
     const matrix = new THREE.Matrix4();
     matrix.makeRotationY(-Math.PI / 2);
     matrix.setPosition(width / 2, 0, 0);
-    geometry.applyMatrix4(matrix);
+    extrudedGeometry.applyMatrix4(matrix);
+    extrudedGeometry.computeVertexNormals();
+    const geometry = extrudedGeometry.toNonIndexed() ?? extrudedGeometry;
+    if (geometry !== extrudedGeometry) {
+        extrudedGeometry.dispose();
+    }
+    applyStairSegmentUvs(geometry);
+    ensureUv2Attribute(geometry);
     return geometry;
 }
 function updateStairSegmentGeometry(node, mesh) {
     // Compute absolute height from parent chain
     const absoluteHeight = computeAbsoluteHeight(node);
     const newGeometry = generateStairSegmentGeometry(node, absoluteHeight);
+    applyStraightStairMaterialGroups(newGeometry);
     mesh.geometry.dispose();
     mesh.geometry = newGeometry;
     // NOTE: position/rotation are NOT set here — they're set by syncSegmentMeshTransforms
@@ -246,14 +280,16 @@ function updateMergedStairGeometry(stairNode, group, nodes) {
     const mergedMesh = group.getObjectByName('merged-stair');
     if (!mergedMesh)
         return;
+    if (stairNode.stairType === 'curved' || stairNode.stairType === 'spiral') {
+        replaceMeshGeometry(mergedMesh, createEmptyGeometry());
+        return;
+    }
     const children = stairNode.children ?? [];
     const segments = children
         .map((childId) => nodes[childId])
         .filter((n) => n?.type === 'stair-segment');
     if (segments.length === 0) {
-        mergedMesh.geometry.dispose();
-        mergedMesh.geometry = new THREE.BufferGeometry();
-        mergedMesh.geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+        replaceMeshGeometry(mergedMesh, createEmptyGeometry());
         return;
     }
     // Compute chained transforms for segments
@@ -271,16 +307,94 @@ function updateMergedStairGeometry(stairNode, group, nodes) {
         geo.applyMatrix4(_matrix);
         geometries.push(geo);
     }
-    const merged = mergeGeometries(geometries, false);
-    if (merged) {
-        mergedMesh.geometry.dispose();
-        mergedMesh.geometry = merged;
-    }
+    const merged = mergeGeometries(geometries, false) ?? createEmptyGeometry();
+    applyStraightStairMaterialGroups(merged);
+    replaceMeshGeometry(mergedMesh, merged);
     // Dispose individual geometries
     for (const geo of geometries) {
         geo.dispose();
     }
 }
+function applyStraightStairMaterialGroups(geometry) {
+    const position = geometry.getAttribute('position');
+    if (!position || position.count < 3) {
+        geometry.clearGroups();
+        return;
+    }
+    const index = geometry.getIndex();
+    const triangleCount = index ? index.count / 3 : position.count / 3;
+    if (!Number.isFinite(triangleCount) || triangleCount <= 0) {
+        geometry.clearGroups();
+        return;
+    }
+    const triangleMaterials = new Array(triangleCount);
+    const v0 = new THREE.Vector3();
+    const v1 = new THREE.Vector3();
+    const v2 = new THREE.Vector3();
+    const edge1 = new THREE.Vector3();
+    const edge2 = new THREE.Vector3();
+    const normal = new THREE.Vector3();
+    for (let triangleIndex = 0; triangleIndex < triangleCount; triangleIndex++) {
+        const vertexOffset = triangleIndex * 3;
+        const a = index ? index.getX(vertexOffset) : vertexOffset;
+        const b = index ? index.getX(vertexOffset + 1) : vertexOffset + 1;
+        const c = index ? index.getX(vertexOffset + 2) : vertexOffset + 2;
+        v0.fromBufferAttribute(position, a);
+        v1.fromBufferAttribute(position, b);
+        v2.fromBufferAttribute(position, c);
+        edge1.subVectors(v1, v0);
+        edge2.subVectors(v2, v0);
+        normal.crossVectors(edge1, edge2);
+        triangleMaterials[triangleIndex] =
+            normal.lengthSq() > 0 && normal.normalize().y > 0.75
+                ? STAIR_TREAD_MATERIAL_INDEX
+                : STAIR_SIDE_MATERIAL_INDEX;
+    }
+    geometry.clearGroups();
+    let currentMaterial = triangleMaterials[0];
+    let groupStart = 0;
+    for (let triangleIndex = 1; triangleIndex < triangleMaterials.length; triangleIndex++) {
+        const materialIndex = triangleMaterials[triangleIndex];
+        if (materialIndex === currentMaterial)
+            continue;
+        geometry.addGroup(groupStart * 3, (triangleIndex - groupStart) * 3, currentMaterial);
+        groupStart = triangleIndex;
+        currentMaterial = materialIndex;
+    }
+    geometry.addGroup(groupStart * 3, (triangleMaterials.length - groupStart) * 3, currentMaterial ?? STAIR_SIDE_MATERIAL_INDEX);
+}
+function applyStairSegmentUvs(geometry) {
+    const position = geometry.getAttribute('position');
+    const normal = geometry.getAttribute('normal');
+    if (!position || !normal || position.count === 0) {
+        geometry.deleteAttribute('uv');
+        return;
+    }
+    const uv = [];
+    for (let index = 0; index < position.count; index++) {
+        _uvPosition.fromBufferAttribute(position, index);
+        _uvNormal.fromBufferAttribute(normal, index).normalize();
+        const absX = Math.abs(_uvNormal.x);
+        const absY = Math.abs(_uvNormal.y);
+        const absZ = Math.abs(_uvNormal.z);
+        if (absY >= absX && absY >= absZ) {
+            uv.push(_uvPosition.x, _uvPosition.z);
+        }
+        else if (absX >= absZ) {
+            uv.push(_uvPosition.z, _uvPosition.y);
+        }
+        else {
+            uv.push(_uvPosition.x, _uvPosition.y);
+        }
+    }
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+}
+function ensureUv2Attribute(geometry) {
+    const uv = geometry.getAttribute('uv');
+    if (!uv)
+        return;
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
+}
 /**
  * Computes world-relative transforms for each segment by chaining
  * based on attachmentSide. This mirrors the prototype's StairSystem logic.
@@ -332,6 +446,314 @@ function rotateXZ(x, z, angle) {
     const sin = Math.sin(angle);
     return [x * cos + z * sin, -x * sin + z * cos];
 }
+function createEmptyGeometry() {
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+    geometry.addGroup(0, 0, STAIR_TREAD_MATERIAL_INDEX);
+    geometry.addGroup(0, 0, STAIR_SIDE_MATERIAL_INDEX);
+    return geometry;
+}
+function replaceMeshGeometry(mesh, geometry) {
+    mesh.geometry.dispose();
+    mesh.geometry = geometry;
+}
+function generateStairRailingGeometry(stairNode, segments, transforms) {
+    const railingMode = stairNode.railingMode ?? 'none';
+    if (railingMode === 'none') {
+        return createEmptyGeometry();
+    }
+    const railHeight = Math.max(0.5, stairNode.railingHeight ?? 0.92);
+    const midRailHeight = Math.max(railHeight * 0.45, 0.35);
+    const railRadius = 0.022;
+    const postRadius = 0.018;
+    const inset = 0.06;
+    const landingInset = 0.08;
+    const geometries = [];
+    const segmentRailPaths = buildStairRailPaths(segments, transforms, railingMode, inset, landingInset);
+    for (const segmentRailPath of segmentRailPaths) {
+        for (const sidePath of segmentRailPath.sidePaths) {
+            const points = sidePath.points;
+            if (points.length === 0)
+                continue;
+            geometries.push(...buildBalusterGeometries(points, railHeight, postRadius));
+            geometries.push(...buildOffsetRailSegmentGeometries(points, railHeight, railRadius));
+            geometries.push(...buildOffsetRailSegmentGeometries(points, midRailHeight, railRadius * 0.8));
+        }
+    }
+    for (let index = 1; index < segmentRailPaths.length; index++) {
+        const previousPath = segmentRailPaths[index - 1];
+        const currentPath = segmentRailPaths[index];
+        if (!(previousPath && currentPath && currentPath.connectFromPrevious))
+            continue;
+        if (previousPath.segment.segmentType === 'landing')
+            continue;
+        for (const sidePath of currentPath.sidePaths) {
+            if (currentPath.segment.segmentType === 'landing')
+                continue;
+            const currentPoint = sidePath.points[0];
+            if (!currentPoint)
+                continue;
+            const previousSidePath = [...previousPath.sidePaths]
+                .map((entry) => ({
+                entry,
+                distance: entry.points.length
+                    ? entry.points[entry.points.length - 1].distanceTo(currentPoint)
+                    : Number.POSITIVE_INFINITY,
+            }))
+                .sort((left, right) => left.distance - right.distance)[0]?.entry;
+            const previousPoint = previousSidePath && previousSidePath.points.length > 0
+                ? previousSidePath.points[previousSidePath.points.length - 1]
+                : null;
+            if (!(previousPoint && currentPoint))
+                continue;
+            const connectorPoints = [previousPoint, currentPoint];
+            geometries.push(...buildOffsetRailSegmentGeometries(connectorPoints, railHeight, railRadius));
+            geometries.push(...buildOffsetRailSegmentGeometries(connectorPoints, midRailHeight, railRadius * 0.8));
+        }
+    }
+    const merged = mergeGeometries(geometries, false) ?? createEmptyGeometry();
+    for (const geometry of geometries) {
+        geometry.dispose();
+    }
+    return merged;
+}
+function buildStairRailPaths(segments, transforms, railingMode, inset, landingInset) {
+    const layouts = computeStairRailLayouts(segments, transforms);
+    if (railingMode === 'both') {
+        const isStraightLineDoubleLandingLayout = segments.length === 4 &&
+            segments[0]?.segmentType === 'stair' &&
+            segments[1]?.segmentType === 'landing' &&
+            segments[2]?.segmentType === 'stair' &&
+            segments[2]?.attachmentSide === 'front' &&
+            segments[3]?.segmentType === 'landing' &&
+            segments[3]?.attachmentSide === 'front';
+        return layouts.map((layout, index) => {
+            const segment = layout.segment;
+            const previousSegment = index > 0 ? segments[index - 1] : undefined;
+            const nextSegment = index < segments.length - 1 ? segments[index + 1] : undefined;
+            const hideLandingRailing = segment.segmentType === 'landing' &&
+                previousSegment?.segmentType === 'stair' &&
+                nextSegment?.segmentType === 'stair';
+            const visualTurnSide = nextSegment?.attachmentSide;
+            const sideCandidates = hideLandingRailing
+                ? visualTurnSide === 'left'
+                    ? ['front', 'right']
+                    : visualTurnSide === 'right'
+                        ? ['front', 'left']
+                        : ['left', 'right']
+                : segment.segmentType === 'landing'
+                    ? nextSegment?.segmentType === 'landing' && visualTurnSide === 'left'
+                        ? ['front', 'right']
+                        : nextSegment?.segmentType === 'landing' && visualTurnSide === 'right'
+                            ? ['front', 'left']
+                            : visualTurnSide === 'left'
+                                ? ['right']
+                                : visualTurnSide === 'right'
+                                    ? ['left']
+                                    : ['left', 'right']
+                    : ['left', 'right'];
+            const sidePaths = sideCandidates
+                .map((side) => buildSegmentRailPath(layout, side, previousSegment, nextSegment, inset, landingInset))
+                .filter((entry) => entry !== null);
+            return {
+                segment,
+                sidePaths: isStraightLineDoubleLandingLayout && index === 1
+                    ? (['left', 'right']
+                        .map((side) => buildSegmentRailPath(layout, side, previousSegment, nextSegment, inset, landingInset))
+                        .filter((entry) => entry !== null))
+                    : sidePaths,
+                connectFromPrevious: index > 0 &&
+                    !(previousSegment?.segmentType === 'landing' && segment.segmentType === 'landing'),
+            };
+        });
+    }
+    const isStraightLineDoubleLandingLayout = segments.length === 4 &&
+        segments[0]?.segmentType === 'stair' &&
+        segments[1]?.segmentType === 'landing' &&
+        segments[2]?.segmentType === 'stair' &&
+        segments[2]?.attachmentSide === 'front' &&
+        segments[3]?.segmentType === 'landing' &&
+        segments[3]?.attachmentSide === 'front';
+    const resolved = [];
+    layouts.forEach((layout, index) => {
+        const segment = layout.segment;
+        const previousSegment = index > 0 ? segments[index - 1] : undefined;
+        const nextSegment = index < segments.length - 1 ? segments[index + 1] : undefined;
+        const nextAttachmentSide = nextSegment?.attachmentSide;
+        const isMiddleLandingBetweenFlights = segment.segmentType === 'landing' &&
+            previousSegment?.segmentType === 'stair' &&
+            nextSegment?.segmentType === 'stair';
+        const suppressLandingRailing = segment.segmentType === 'landing' &&
+            nextSegment?.segmentType === 'landing' &&
+            nextAttachmentSide === railingMode;
+        const landingContinuesOnPreferredSide = segment.segmentType === 'landing'
+            ? nextAttachmentSide == null ||
+                nextAttachmentSide === 'front' ||
+                nextAttachmentSide === railingMode
+            : true;
+        const sidePaths = suppressLandingRailing
+            ? []
+            : segment.segmentType !== 'landing'
+                ? [
+                    buildSegmentRailPath(layout, railingMode, previousSegment, nextSegment, inset, landingInset),
+                ]
+                : isStraightLineDoubleLandingLayout
+                    ? [
+                        buildSegmentRailPath(layout, railingMode, previousSegment, nextSegment, inset, landingInset),
+                    ]
+                    : isMiddleLandingBetweenFlights && railingMode === 'left'
+                        ? nextAttachmentSide === 'right'
+                            ? [
+                                buildSegmentRailPath(layout, 'front', previousSegment, nextSegment, inset, landingInset),
+                                buildSegmentRailPath(layout, 'left', previousSegment, nextSegment, inset, landingInset),
+                            ]
+                            : []
+                        : isMiddleLandingBetweenFlights && railingMode === 'right'
+                            ? nextAttachmentSide === 'left'
+                                ? [
+                                    buildSegmentRailPath(layout, 'front', previousSegment, nextSegment, inset, landingInset),
+                                    buildSegmentRailPath(layout, 'right', previousSegment, nextSegment, inset, landingInset),
+                                ]
+                                : []
+                            : nextSegment?.segmentType === 'landing' &&
+                                nextAttachmentSide != null &&
+                                nextAttachmentSide !== 'front' &&
+                                nextAttachmentSide !== railingMode
+                                ? [
+                                    buildSegmentRailPath(layout, 'front', previousSegment, nextSegment, inset, landingInset),
+                                    buildSegmentRailPath(layout, railingMode, previousSegment, nextSegment, inset, landingInset),
+                                ]
+                                : [
+                                    buildSegmentRailPath(layout, railingMode, previousSegment, nextSegment, inset, landingInset),
+                                ];
+        resolved.push({
+            segment,
+            sidePaths: sidePaths.filter((entry) => entry !== null),
+            connectFromPrevious: index > 0 &&
+                !suppressLandingRailing &&
+                sidePaths.length > 0 &&
+                (segment.segmentType === 'landing' ? landingContinuesOnPreferredSide : true),
+        });
+    });
+    return resolved;
+}
+function computeStairRailLayouts(segments, transforms) {
+    return segments.map((segment, index) => {
+        const transform = transforms[index];
+        const [centerOffsetX, centerOffsetZ] = rotateXZ(0, segment.length / 2, transform.rotation);
+        return {
+            center: [transform.position[0] + centerOffsetX, transform.position[2] + centerOffsetZ],
+            elevation: transform.position[1],
+            rotation: transform.rotation,
+            segment,
+        };
+    });
+}
+function buildSegmentRailPath(layout, side, previousSegment, nextSegment, inset, landingInset) {
+    const segment = layout.segment;
+    const segmentSteps = Math.max(1, segment.segmentType === 'landing' ? 1 : segment.stepCount);
+    const segmentStepDepth = segment.length / segmentSteps;
+    const segmentStepHeight = segment.segmentType === 'landing' ? 0 : segment.height / segmentSteps;
+    const segmentTopThickness = getSegmentTopThickness(segment);
+    const flightSideOffset = side === 'left' ? segment.width / 2 - 0.045 : -segment.width / 2 + 0.045;
+    const flightStartX = previousSegment?.segmentType === 'landing' ? -segment.length / 2 + landingInset : -segment.length / 2;
+    const flightEndX = nextSegment?.segmentType === 'landing' ? segment.length / 2 - landingInset : segment.length / 2;
+    if (segment.segmentType === 'landing') {
+        return buildLandingRailPathFromScratch(layout, side, previousSegment, nextSegment, segmentTopThickness, landingInset);
+    }
+    return {
+        side,
+        points: [
+            ...(previousSegment?.segmentType === 'landing'
+                ? []
+                : [
+                    toRailLayoutWorldPoint(layout, flightStartX, segmentTopThickness, flightSideOffset),
+                ]),
+            ...Array.from({ length: segmentSteps }).map((_, index) => toRailLayoutWorldPoint(layout, -segment.length / 2 + segmentStepDepth * index + segmentStepDepth / 2, segmentStepHeight * (index + 1), flightSideOffset)),
+            ...(nextSegment?.segmentType === 'landing'
+                ? []
+                : [
+                    toRailLayoutWorldPoint(layout, flightEndX, segment.height, flightSideOffset),
+                ]),
+        ],
+    };
+}
+function buildLandingRailPathFromScratch(layout, side, previousSegment, nextSegment, topY, inset) {
+    const segment = layout.segment;
+    const backX = -segment.length / 2 + inset;
+    const frontX = segment.length / 2 - inset;
+    const leftZ = segment.width / 2 - inset;
+    const rightZ = -segment.width / 2 + inset;
+    const edgePoints = side === 'left'
+        ? [
+            toRailLayoutWorldPoint(layout, backX, topY, leftZ),
+            toRailLayoutWorldPoint(layout, frontX, topY, leftZ),
+        ]
+        : side === 'right'
+            ? [
+                toRailLayoutWorldPoint(layout, backX, topY, rightZ),
+                toRailLayoutWorldPoint(layout, frontX, topY, rightZ),
+            ]
+            : [
+                // When the next flight turns, rail the visible leading edge nearest the turn opening.
+                toRailLayoutWorldPoint(layout, previousSegment?.segmentType === 'stair' &&
+                    nextSegment?.attachmentSide &&
+                    nextSegment.attachmentSide !== 'front'
+                    ? backX
+                    : frontX, topY, leftZ),
+                toRailLayoutWorldPoint(layout, previousSegment?.segmentType === 'stair' &&
+                    nextSegment?.attachmentSide &&
+                    nextSegment.attachmentSide !== 'front'
+                    ? backX
+                    : frontX, topY, rightZ),
+            ];
+    return {
+        side,
+        points: edgePoints,
+    };
+}
+function toRailLayoutWorldPoint(layout, localX, localY, localZ) {
+    const [offsetX, offsetZ] = rotateXZ(localZ, localX, layout.rotation);
+    return new THREE.Vector3(layout.center[0] + offsetX, layout.elevation + localY, layout.center[1] + offsetZ);
+}
+function buildOffsetRailSegmentGeometries(points, heightOffset, radius) {
+    const geometries = [];
+    for (let index = 0; index < points.length - 1; index++) {
+        const start = points[index];
+        const end = points[index + 1];
+        if (!(start && end))
+            continue;
+        const segmentGeometry = createCylinderBetweenPoints(start.clone().add(new THREE.Vector3(0, heightOffset, 0)), end.clone().add(new THREE.Vector3(0, heightOffset, 0)), radius, 8);
+        if (segmentGeometry) {
+            geometries.push(segmentGeometry);
+        }
+    }
+    return geometries;
+}
+function buildBalusterGeometries(points, height, radius) {
+    const geometries = [];
+    for (const point of points) {
+        const geometry = new THREE.CylinderGeometry(radius, radius, Math.max(height, 0.05), 8);
+        geometry.translate(point.x, point.y + height / 2, point.z);
+        geometries.push(geometry);
+    }
+    return geometries;
+}
+function getSegmentTopThickness(segment) {
+    return Math.max(segment.thickness ?? 0.25, 0.02);
+}
+function createCylinderBetweenPoints(start, end, radius, radialSegments) {
+    const direction = new THREE.Vector3().subVectors(end, start);
+    const length = direction.length();
+    if (length <= 1e-5)
+        return null;
+    const midpoint = new THREE.Vector3().addVectors(start, end).multiplyScalar(0.5);
+    const quaternion = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), direction.clone().normalize());
+    const geometry = new THREE.CylinderGeometry(radius, radius, length, radialSegments);
+    geometry.applyQuaternion(quaternion);
+    geometry.translate(midpoint.x, midpoint.y, midpoint.z);
+    return geometry;
+}
 /**
  * Computes the absolute Y height of a segment by traversing the stair's segment chain.
  */

package/dist/systems/wall/wall-curve.d.ts

@@ -0,0 +1,43 @@
+import type { Point2D } from './wall-mitering';
+import type { FenceNode, WallNode } from '../../schema';
+type WallCurveLike = Pick<WallNode | FenceNode, 'start' | 'end' | 'curveOffset'>;
+type CurveFrame = {
+    point: Point2D;
+    tangent: Point2D;
+    normal: Point2D;
+};
+type WallSurfaceMiterOverrides = {
+    startLeft?: Point2D;
+    startRight?: Point2D;
+    endLeft?: Point2D;
+    endRight?: Point2D;
+};
+export declare function getWallStartPoint(wall: WallCurveLike): Point2D;
+export declare function getWallEndPoint(wall: WallCurveLike): Point2D;
+export declare function getWallChordLength(wall: WallCurveLike): number;
+export declare function getMaxWallCurveOffset(wall: WallCurveLike): number;
+export declare function getWallStraightSnapOffset(wall: WallCurveLike): number;
+export declare function normalizeWallCurveOffset(wall: WallCurveLike, offset: number): number;
+export declare function getClampedWallCurveOffset(wall: WallCurveLike): number;
+export declare function isCurvedWall(wall: WallCurveLike): boolean;
+export declare function getWallChordFrame(wall: WallCurveLike): {
+    start: Point2D;
+    end: Point2D;
+    midpoint: Point2D;
+    tangent: {
+        x: number;
+        y: number;
+    };
+    normal: {
+        x: number;
+        y: number;
+    };
+    length: number;
+};
+export declare function getWallCurveFrameAt(wall: WallCurveLike, t: number): CurveFrame;
+export declare function getWallMidpointHandlePoint(wall: WallCurveLike): Point2D;
+export declare function sampleWallCenterline(wall: WallCurveLike, segments?: number): Point2D[];
+export declare function getWallCurveLength(wall: WallCurveLike, segments?: number): number;
+export declare function getWallSurfacePolygon(wall: Pick<WallNode | FenceNode, 'start' | 'end' | 'curveOffset' | 'thickness'>, segments?: number, miterOverrides?: WallSurfaceMiterOverrides): Point2D[];
+export {};
+//# sourceMappingURL=wall-curve.d.ts.map

package/dist/systems/wall/wall-curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-curve.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAKvD,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAC,CAAA;AAEhF,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAcD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE9D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,UAErD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,UAExD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAE5D;AAWD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,UAG3E;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAI5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,WAE/C;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa;;;;;;;;;;;;;EA6BpD;AA+BD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAwC9E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,aAAa,WAE7D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,aAG3F;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,UASzF;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,GAAG,WAAW,CAAC,EAC/E,QAAQ,SAA0B,EAClC,cAAc,CAAC,EAAE,yBAAyB,aA2B3C"}