@pascal-app/core 0.5.1 → 0.7.0

package/dist/store/use-scene.js

@@ -5,7 +5,233 @@ import { BuildingNode } from '../schema';
 import { generateCollectionId } from '../schema/collections';
 import { LevelNode } from '../schema/nodes/level';
 import { SiteNode } from '../schema/nodes/site';
+import { StairNode as StairNodeSchema } from '../schema/nodes/stair';
+import { StairSegmentNode as StairSegmentNodeSchema } from '../schema/nodes/stair-segment';
 import * as nodeActions from './actions/node-actions';
+import { resetSceneHistoryPauseDepth } from './history-control';
+function getFiniteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function getBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function getEnumValue(value, allowed, fallback) {
+    return typeof value === 'string' && allowed.includes(value) ? value : fallback;
+}
+function getNullableString(value) {
+    return typeof value === 'string' ? value : null;
+}
+function getStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === 'string')
+        : [];
+}
+function getVector3(value, fallback) {
+    if (!Array.isArray(value) || value.length < 3) {
+        return fallback;
+    }
+    return [
+        getFiniteNumber(value[0], fallback[0]),
+        getFiniteNumber(value[1], fallback[1]),
+        getFiniteNumber(value[2], fallback[2]),
+    ];
+}
+function normalizeStairNode(node) {
+    const sanitized = {
+        ...node,
+        position: getVector3(node.position, [0, 0, 0]),
+        rotation: getFiniteNumber(node.rotation, 0),
+        stairType: getEnumValue(node.stairType, ['straight', 'curved', 'spiral'], 'straight'),
+        fromLevelId: getNullableString(node.fromLevelId),
+        toLevelId: getNullableString(node.toLevelId),
+        slabOpeningMode: getEnumValue(node.slabOpeningMode, ['none', 'destination'], 'none'),
+        openingOffset: getFiniteNumber(node.openingOffset, 0),
+        width: getFiniteNumber(node.width, 1),
+        totalRise: getFiniteNumber(node.totalRise, 2.5),
+        stepCount: getFiniteNumber(node.stepCount, 10),
+        thickness: getFiniteNumber(node.thickness, 0.25),
+        fillToFloor: getBoolean(node.fillToFloor, true),
+        innerRadius: getFiniteNumber(node.innerRadius, 0.9),
+        sweepAngle: getFiniteNumber(node.sweepAngle, Math.PI / 2),
+        topLandingMode: getEnumValue(node.topLandingMode, ['none', 'integrated'], 'none'),
+        topLandingDepth: getFiniteNumber(node.topLandingDepth, 0.9),
+        showCenterColumn: getBoolean(node.showCenterColumn, true),
+        showStepSupports: getBoolean(node.showStepSupports, true),
+        railingMode: getEnumValue(node.railingMode, ['none', 'left', 'right', 'both'], 'none'),
+        railingHeight: getFiniteNumber(node.railingHeight, 0.92),
+        children: getStringArray(node.children),
+    };
+    const parsed = StairNodeSchema.safeParse(sanitized);
+    return parsed.success ? parsed.data : null;
+}
+function normalizeStairSegmentNode(node) {
+    const sanitized = {
+        ...node,
+        position: getVector3(node.position, [0, 0, 0]),
+        rotation: getFiniteNumber(node.rotation, 0),
+        segmentType: getEnumValue(node.segmentType, ['stair', 'landing'], 'stair'),
+        width: getFiniteNumber(node.width, 1),
+        length: getFiniteNumber(node.length, 3),
+        height: getFiniteNumber(node.height, 2.5),
+        stepCount: getFiniteNumber(node.stepCount, 10),
+        attachmentSide: getEnumValue(node.attachmentSide, ['front', 'left', 'right'], 'front'),
+        fillToFloor: getBoolean(node.fillToFloor, true),
+        thickness: getFiniteNumber(node.thickness, 0.25),
+    };
+    const parsed = StairSegmentNodeSchema.safeParse(sanitized);
+    return parsed.success ? parsed.data : null;
+}
+function migrateWallSurfaceMaterials(node) {
+    const hasInterior = node.interiorMaterial !== undefined || typeof node.interiorMaterialPreset === 'string';
+    const hasExterior = node.exteriorMaterial !== undefined || typeof node.exteriorMaterialPreset === 'string';
+    const legacyFinish = {
+        material: node.material,
+        materialPreset: typeof node.materialPreset === 'string' ? node.materialPreset : undefined,
+    };
+    if (!hasInterior && !hasExterior) {
+        if (legacyFinish.material === undefined && legacyFinish.materialPreset === undefined) {
+            return node;
+        }
+        return {
+            ...node,
+            interiorMaterial: legacyFinish.material,
+            interiorMaterialPreset: legacyFinish.materialPreset,
+            exteriorMaterial: legacyFinish.material,
+            exteriorMaterialPreset: legacyFinish.materialPreset,
+        };
+    }
+    if (!hasInterior) {
+        return {
+            ...node,
+            interiorMaterial: node.exteriorMaterial,
+            interiorMaterialPreset: node.exteriorMaterialPreset,
+        };
+    }
+    if (!hasExterior) {
+        return {
+            ...node,
+            exteriorMaterial: node.interiorMaterial,
+            exteriorMaterialPreset: node.interiorMaterialPreset,
+        };
+    }
+    return node;
+}
+function migrateStairSurfaceMaterials(node) {
+    const hasRailing = node.railingMaterial !== undefined || typeof node.railingMaterialPreset === 'string';
+    const hasTread = node.treadMaterial !== undefined || typeof node.treadMaterialPreset === 'string';
+    const hasSide = node.sideMaterial !== undefined || typeof node.sideMaterialPreset === 'string';
+    const legacyFinish = {
+        material: node.material,
+        materialPreset: typeof node.materialPreset === 'string' ? node.materialPreset : undefined,
+    };
+    const resolveBodyFallback = () => {
+        if (node.treadMaterial !== undefined || typeof node.treadMaterialPreset === 'string') {
+            return {
+                material: node.treadMaterial,
+                materialPreset: typeof node.treadMaterialPreset === 'string' ? node.treadMaterialPreset : undefined,
+            };
+        }
+        if (node.sideMaterial !== undefined || typeof node.sideMaterialPreset === 'string') {
+            return {
+                material: node.sideMaterial,
+                materialPreset: typeof node.sideMaterialPreset === 'string' ? node.sideMaterialPreset : undefined,
+            };
+        }
+        return legacyFinish;
+    };
+    if (!hasRailing && !hasTread && !hasSide) {
+        if (legacyFinish.material === undefined && legacyFinish.materialPreset === undefined) {
+            return node;
+        }
+        return {
+            ...node,
+            railingMaterial: legacyFinish.material,
+            railingMaterialPreset: legacyFinish.materialPreset,
+            treadMaterial: legacyFinish.material,
+            treadMaterialPreset: legacyFinish.materialPreset,
+            sideMaterial: legacyFinish.material,
+            sideMaterialPreset: legacyFinish.materialPreset,
+        };
+    }
+    const next = { ...node };
+    if (!hasTread) {
+        const fallback = node.sideMaterial !== undefined || typeof node.sideMaterialPreset === 'string'
+            ? {
+                material: node.sideMaterial,
+                materialPreset: typeof node.sideMaterialPreset === 'string' ? node.sideMaterialPreset : undefined,
+            }
+            : resolveBodyFallback();
+        next.treadMaterial = fallback.material;
+        next.treadMaterialPreset = fallback.materialPreset;
+    }
+    if (!hasSide) {
+        const fallback = node.treadMaterial !== undefined || typeof node.treadMaterialPreset === 'string'
+            ? {
+                material: node.treadMaterial,
+                materialPreset: typeof node.treadMaterialPreset === 'string' ? node.treadMaterialPreset : undefined,
+            }
+            : resolveBodyFallback();
+        next.sideMaterial = fallback.material;
+        next.sideMaterialPreset = fallback.materialPreset;
+    }
+    if (!hasRailing) {
+        const fallback = resolveBodyFallback();
+        next.railingMaterial = fallback.material;
+        next.railingMaterialPreset = fallback.materialPreset;
+    }
+    return next;
+}
+function migrateRoofSurfaceMaterials(node) {
+    const hasTop = node.topMaterial !== undefined || typeof node.topMaterialPreset === 'string';
+    const hasEdge = node.edgeMaterial !== undefined || typeof node.edgeMaterialPreset === 'string';
+    const hasWall = node.wallMaterial !== undefined || typeof node.wallMaterialPreset === 'string';
+    const legacyFinish = {
+        material: node.material,
+        materialPreset: typeof node.materialPreset === 'string' ? node.materialPreset : undefined,
+    };
+    if (!hasTop && !hasEdge && !hasWall) {
+        if (legacyFinish.material === undefined && legacyFinish.materialPreset === undefined) {
+            return node;
+        }
+        return {
+            ...node,
+            topMaterial: legacyFinish.material,
+            topMaterialPreset: legacyFinish.materialPreset,
+            edgeMaterial: legacyFinish.material,
+            edgeMaterialPreset: legacyFinish.materialPreset,
+            wallMaterial: legacyFinish.material,
+            wallMaterialPreset: legacyFinish.materialPreset,
+        };
+    }
+    const next = { ...node };
+    if (!hasTop) {
+        next.topMaterial = legacyFinish.material;
+        next.topMaterialPreset = legacyFinish.materialPreset;
+    }
+    if (!hasEdge) {
+        if (node.wallMaterial !== undefined || typeof node.wallMaterialPreset === 'string') {
+            next.edgeMaterial = node.wallMaterial;
+            next.edgeMaterialPreset =
+                typeof node.wallMaterialPreset === 'string' ? node.wallMaterialPreset : undefined;
+        }
+        else {
+            next.edgeMaterial = legacyFinish.material;
+            next.edgeMaterialPreset = legacyFinish.materialPreset;
+        }
+    }
+    if (!hasWall) {
+        if (node.edgeMaterial !== undefined || typeof node.edgeMaterialPreset === 'string') {
+            next.wallMaterial = node.edgeMaterial;
+            next.wallMaterialPreset =
+                typeof node.edgeMaterialPreset === 'string' ? node.edgeMaterialPreset : undefined;
+        }
+        else {
+            next.wallMaterial = legacyFinish.material;
+            next.wallMaterialPreset = legacyFinish.materialPreset;
+        }
+    }
+    return next;
+}
 function migrateNodes(nodes) {
     const patchedNodes = { ...nodes };
     for (const [id, node] of Object.entries(patchedNodes)) {
@@ -43,9 +269,75 @@ function migrateNodes(nodes) {
                 children: [segmentId],
             };
         }
+        if (node.type === 'stair') {
+            const normalized = normalizeStairNode(migrateStairSurfaceMaterials(node));
+            if (normalized) {
+                patchedNodes[id] = normalized;
+            }
+        }
+        if (node.type === 'stair-segment') {
+            const normalized = normalizeStairSegmentNode(node);
+            if (normalized) {
+                patchedNodes[id] = normalized;
+            }
+        }
+        if (node.type === 'wall') {
+            patchedNodes[id] = migrateWallSurfaceMaterials(patchedNodes[id]);
+        }
+        if (node.type === 'roof') {
+            patchedNodes[id] = migrateRoofSurfaceMaterials(patchedNodes[id]);
+        }
     }
     return patchedNodes;
 }
+function getNodeChildIds(node) {
+    if (!('children' in node) || !Array.isArray(node.children)) {
+        return [];
+    }
+    return node.children
+        .map((child) => {
+        if (typeof child === 'string')
+            return child;
+        if (child && typeof child === 'object' && 'id' in child && typeof child.id === 'string') {
+            return child.id;
+        }
+        return null;
+    })
+        .filter((id) => typeof id === 'string');
+}
+function normalizeRootNodeIds(nodes, rootNodeIds) {
+    const existingRootIds = rootNodeIds.filter((id) => Boolean(nodes[id]));
+    const siteRootIds = existingRootIds.filter((id) => nodes[id]?.type === 'site');
+    if (siteRootIds.length > 0) {
+        return siteRootIds;
+    }
+    return existingRootIds.filter((id) => nodes[id]?.parentId === null);
+}
+function collectReachableNodeIds(nodes, rootNodeIds) {
+    const reachable = new Set();
+    const stack = [...rootNodeIds];
+    const childIdsByParentId = new Map();
+    for (const node of Object.values(nodes)) {
+        if (!node.parentId)
+            continue;
+        const parentId = node.parentId;
+        const children = childIdsByParentId.get(parentId) ?? [];
+        children.push(node.id);
+        childIdsByParentId.set(parentId, children);
+    }
+    while (stack.length > 0) {
+        const id = stack.pop();
+        if (!id || reachable.has(id))
+            continue;
+        const node = nodes[id];
+        if (!node)
+            continue;
+        reachable.add(id);
+        stack.push(...getNodeChildIds(node));
+        stack.push(...(childIdsByParentId.get(id) ?? []));
+    }
+    return reachable;
+}
 const useScene = create()(temporal((set, get) => ({
     // 1. Flat dictionary of all nodes
     nodes: {},
@@ -81,9 +373,19 @@ const useScene = create()(temporal((set, get) => ({
                 delete cleanedNodes[node.id];
             }
         }
+        const normalizedRootNodeIds = normalizeRootNodeIds(cleanedNodes, rootNodeIds);
+        const reachableNodeIds = collectReachableNodeIds(cleanedNodes, normalizedRootNodeIds);
+        if (normalizedRootNodeIds.length > 0) {
+            for (const node of Object.values(cleanedNodes)) {
+                if (reachableNodeIds.has(node.id))
+                    continue;
+                console.warn('[Scene] Removing unreachable node', node.id);
+                delete cleanedNodes[node.id];
+            }
+        }
         set({
             nodes: cleanedNodes,
-            rootNodeIds,
+            rootNodeIds: normalizedRootNodeIds,
             dirtyNodes: new Set(),
             collections: {},
         });
@@ -246,6 +548,7 @@ let prevFutureLength = 0;
 let prevNodesSnapshot = null;
 export function clearSceneHistory() {
     useScene.temporal.getState().clear();
+    resetSceneHistoryPauseDepth();
     prevPastLength = 0;
     prevFutureLength = 0;
     prevNodesSnapshot = null;
@@ -261,8 +564,9 @@ useScene.temporal.subscribe((state) => {
     if (didUndo || didRedo) {
         // Capture the previous snapshot before RAF fires
         const snapshotBefore = prevNodesSnapshot;
-        // Use RAF to ensure all middleware and store updates are complete
-        requestAnimationFrame(() => {
+        // Defer to a microtask so the scene store has settled before we diff,
+        // but still mark walls/items dirty before the next paint.
+        queueMicrotask(() => {
             const currentNodes = useScene.getState().nodes;
             const { markDirty } = useScene.getState();
             if (snapshotBefore) {

package/dist/systems/ceiling/ceiling-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ceiling-system.d.ts","sourceRoot":"","sources":["../../../src/systems/ceiling/ceiling-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,cAAc,CAAA;AAO1D,eAAO,MAAM,aAAa,YAuBzB,CAAA;AAqBD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,KAAK,CAAC,cAAc,CA+CtF"}
+{"version":3,"file":"ceiling-system.d.ts","sourceRoot":"","sources":["../../../src/systems/ceiling/ceiling-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,cAAc,CAAA;AAc1D,eAAO,MAAM,aAAa,YAuBzB,CAAA;AAqBD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,KAAK,CAAC,cAAc,CAgDtF"}

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

@@ -2,6 +2,12 @@ import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
 import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
 import useScene from '../../store/use-scene';
+function ensureUv2Attribute(geometry) {
+    const uv = geometry.getAttribute('uv');
+    if (!uv)
+        return;
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
+}
 // ============================================================================
 // CEILING SYSTEM
 // ============================================================================
@@ -81,5 +87,6 @@ export function generateCeilingGeometry(ceilingNode) {
     // Rotate so the shape lies flat in X-Z plane
     geometry.rotateX(-Math.PI / 2);
     geometry.computeVertexNormals();
+    ensureUv2Attribute(geometry);
     return geometry;
 }

package/dist/systems/fence/fence-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fence-system.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-system.tsx"],"names":[],"mappings":"AA+HA,eAAO,MAAM,WAAW,YAiBvB,CAAA"}
+{"version":3,"file":"fence-system.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-system.tsx"],"names":[],"mappings":"AAyQA,eAAO,MAAM,WAAW,YAiBvB,CAAA"}

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

@@ -3,6 +3,94 @@ import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { sceneRegistry } from '../../hooks/scene-registry/scene-registry';
 import useScene from '../../store/use-scene';
+import { getWallCurveFrameAt, getWallCurveLength } from '../wall/wall-curve';
+const MIN_CURVE_SEGMENT_LENGTH = 0.18;
+function createFencePartGeometry(part) {
+    const geometry = new THREE.BoxGeometry(1, 1, 1);
+    geometry.scale(part.scale[0], part.scale[1], part.scale[2]);
+    if (part.rotationY) {
+        geometry.rotateY(part.rotationY);
+    }
+    geometry.translate(part.position[0], part.position[1], part.position[2]);
+    applyFenceUVs(geometry);
+    return geometry;
+}
+function getFencePointAt(fence, t) {
+    const frame = getWallCurveFrameAt(fence, t);
+    return {
+        point: frame.point,
+        tangentAngle: Math.atan2(frame.tangent.y, frame.tangent.x),
+    };
+}
+function createStraightFenceSpanPart(start, end, centerY, height, depth) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const length = Math.hypot(dx, dz);
+    if (length <= 1e-4) {
+        return null;
+    }
+    return {
+        position: [(start[0] + end[0]) / 2, centerY, (start[1] + end[1]) / 2],
+        rotationY: -Math.atan2(dz, dx),
+        scale: [length, height, depth],
+    };
+}
+function createFenceCurveSpanParts(fence, startT, endT, centerY, height, depth) {
+    const parts = [];
+    const frameCount = Math.max(1, Math.ceil((getWallCurveLength(fence) * Math.max(1e-4, endT - startT)) / MIN_CURVE_SEGMENT_LENGTH));
+    let previous = getFencePointAt(fence, startT);
+    for (let index = 1; index <= frameCount; index += 1) {
+        const t = startT + (endT - startT) * (index / frameCount);
+        const current = getFencePointAt(fence, t);
+        const segment = createStraightFenceSpanPart([previous.point.x, previous.point.y], [current.point.x, current.point.y], centerY, height, depth);
+        if (segment) {
+            parts.push(segment);
+        }
+        previous = current;
+    }
+    return parts;
+}
+function applyFenceUVs(geometry) {
+    const position = geometry.getAttribute('position');
+    const normal = geometry.getAttribute('normal');
+    if (!(position && normal))
+        return;
+    const uvs = new Float32Array(position.count * 2);
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < position.count; index += 1) {
+        minX = Math.min(minX, position.getX(index));
+        minY = Math.min(minY, position.getY(index));
+        minZ = Math.min(minZ, position.getZ(index));
+    }
+    for (let index = 0; index < position.count; index += 1) {
+        const px = position.getX(index);
+        const py = position.getY(index);
+        const pz = position.getZ(index);
+        const nx = Math.abs(normal.getX(index));
+        const ny = Math.abs(normal.getY(index));
+        const nz = Math.abs(normal.getZ(index));
+        let u = 0;
+        let v = 0;
+        if (ny >= nx && ny >= nz) {
+            u = px - minX;
+            v = pz - minZ;
+        }
+        else if (nx >= nz) {
+            u = pz - minZ;
+            v = py - minY;
+        }
+        else {
+            u = px - minX;
+            v = py - minY;
+        }
+        uvs[index * 2] = u;
+        uvs[index * 2 + 1] = v;
+    }
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(uvs.slice(), 2));
+}
 function getStyleDefaults(style) {
     if (style === 'privacy') {
         return { spacingFactor: 0.42, postFactor: 1.35, baseFactor: 1.2, topFactor: 1.2 };
@@ -14,7 +102,7 @@ function getStyleDefaults(style) {
 }
 function createFenceParts(fence) {
     const parts = [];
-    const length = Math.max(Math.hypot(fence.end[0] - fence.start[0], fence.end[1] - fence.start[1]), 0.01);
+    const length = Math.max(getWallCurveLength(fence), 0.01);
     const panelDepth = Math.max(fence.thickness, 0.03);
     const clearance = Math.max(fence.groundClearance, 0);
     const styleDefaults = getStyleDefaults(fence.style);
@@ -27,61 +115,43 @@ function createFenceParts(fence) {
     const isFloating = fence.baseStyle === 'floating';
     const baseY = isFloating ? clearance : 0;
     const effectiveBaseHeight = baseHeight;
+    const startInsetT = Math.min(0.499, edgeInset / length);
+    const endInsetT = Math.max(0.501, 1 - edgeInset / length);
     if (!isFloating) {
-        parts.push({
-            position: [0, baseY + effectiveBaseHeight / 2, 0],
-            scale: [length, effectiveBaseHeight, panelDepth * 1.05],
-        });
-        parts.push({
-            position: [0, baseY + effectiveBaseHeight + verticalHeight * 0.15, 0],
-            scale: [length, topRailHeight * 0.8, panelDepth * 0.35],
-        });
+        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight / 2, effectiveBaseHeight, panelDepth * 1.05));
+        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight * 0.15, topRailHeight * 0.8, panelDepth * 0.35));
     }
     const count = Math.max(2, Math.floor((length - edgeInset * 2) / spacing) + 1);
-    const step = count > 1 ? (length - edgeInset * 2) / (count - 1) : 0;
-    const startX = -length / 2 + edgeInset;
     const verticalY = baseY + effectiveBaseHeight + verticalHeight / 2;
     for (let index = 0; index < count; index += 1) {
-        const x = count === 1 ? 0 : startX + step * index;
-        let posX = x;
+        const t = count === 1 ? 0.5 : startInsetT + (endInsetT - startInsetT) * (index / (count - 1));
+        const frame = getFencePointAt(fence, t);
         const isEdgePost = index === 0 || index === count - 1;
-        if (count > 1) {
-            if (index === 0)
-                posX = -length / 2 + edgeInset + postWidth / 2;
-            else if (index === count - 1)
-                posX = length / 2 - edgeInset - postWidth / 2;
-        }
         const postHeight = isFloating && isEdgePost
             ? effectiveBaseHeight + verticalHeight + topRailHeight + clearance
             : verticalHeight;
         const postY = isFloating && isEdgePost ? postHeight / 2 : verticalY;
         parts.push({
-            position: [posX, postY, 0],
+            position: [frame.point.x, postY, frame.point.y],
+            rotationY: -frame.tangentAngle,
             scale: [postWidth, postHeight, Math.max(panelDepth * 0.35, 0.012)],
         });
     }
-    parts.push({
-        position: [0, baseY + effectiveBaseHeight + verticalHeight + topRailHeight / 2, 0],
-        scale: [length, topRailHeight, Math.max(panelDepth * 0.55, 0.018)],
-    });
+    parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
     if (isFloating) {
-        parts.push({
-            position: [0, baseY + effectiveBaseHeight + topRailHeight / 2, 0],
-            scale: [length, topRailHeight, Math.max(panelDepth * 0.55, 0.018)],
-        });
+        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
     }
     return parts;
 }
 function generateFenceGeometry(fence) {
     const parts = createFenceParts(fence);
-    const geometries = parts.map((part) => {
-        const geometry = new THREE.BoxGeometry(1, 1, 1);
-        geometry.scale(part.scale[0], part.scale[1], part.scale[2]);
-        geometry.translate(part.position[0], part.position[1], part.position[2]);
-        return geometry;
-    });
+    const geometries = parts.map(createFencePartGeometry);
     const merged = mergeGeometries(geometries, false) ?? new THREE.BufferGeometry();
     geometries.forEach((geometry) => geometry.dispose());
+    const mergedUv = merged.getAttribute('uv');
+    if (mergedUv) {
+        merged.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(mergedUv.array), 2));
+    }
     merged.computeVertexNormals();
     return merged;
 }
@@ -95,11 +165,8 @@ function updateFenceGeometry(fenceId) {
     const newGeometry = generateFenceGeometry(node);
     mesh.geometry.dispose();
     mesh.geometry = newGeometry;
-    const centerX = (node.start[0] + node.end[0]) / 2;
-    const centerZ = (node.start[1] + node.end[1]) / 2;
-    const angle = Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]);
-    mesh.position.set(centerX, 0, centerZ);
-    mesh.rotation.set(0, -angle, 0);
+    mesh.position.set(0, 0, 0);
+    mesh.rotation.set(0, 0, 0);
 }
 export const FenceSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);

package/dist/systems/roof/roof-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAGvE,OAAO,KAAK,EAAgC,eAAe,EAAE,MAAM,cAAc,CAAA;AA+BjF,eAAO,MAAM,UAAU,YAuFtB,CAAA;AAuLD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,GACpB;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CAsRlF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAoDvF"}
+{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAGvE,OAAO,KAAK,EAAgC,eAAe,EAAE,MAAM,cAAc,CAAA;AAgCjF,eAAO,MAAM,UAAU,YAuFtB,CAAA;AAwLD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,GACpB;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CAsRlF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAqDvF"}

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

@@ -8,7 +8,7 @@ import useScene from '../../store/use-scene';
 const csgEvaluator = new Evaluator();
 csgEvaluator.useGroups = true;
 csgEvaluator.consolidateGroups = false; // shared dummyMats across brushes causes consolidation to misalign groupIndices vs groupOrder indices → crash
-csgEvaluator.attributes = ['position', 'normal'];
+csgEvaluator.attributes = ['position', 'normal', 'uv'];
 function prepareBrushForCSG(brush) {
     brush.geometry.computeBoundsTree = computeBoundsTree;
     brush.geometry.computeBoundsTree({ maxLeafSize: 10 });
@@ -20,6 +20,7 @@ const _position = new THREE.Vector3();
 const _quaternion = new THREE.Quaternion();
 const _scale = new THREE.Vector3(1, 1, 1);
 const _yAxis = new THREE.Vector3(0, 1, 0);
+const _uvFaceNormal = new THREE.Vector3();
 // Pending merged-roof updates carried across frames (for throttling)
 const pendingRoofUpdates = new Set();
 const MAX_ROOFS_PER_FRAME = 1;
@@ -217,6 +218,7 @@ function updateMergedRoofGeometry(roofNode, group, nodes) {
             for (const g of resultGeo.groups) {
                 g.materialIndex = mapRoofGroupMaterialIndex(g.materialIndex, resultMaterials, matToIndex);
             }
+            ensureUv2Attribute(resultGeo);
             resultGeo.computeVertexNormals();
             mergedMesh.geometry.dispose();
             mergedMesh.geometry = resultGeo;
@@ -500,6 +502,7 @@ export function generateRoofSegmentGeometry(node) {
     shinSlab.geometry.dispose();
     wallBrush.geometry.dispose();
     innerBrush.geometry.dispose();
+    ensureUv2Attribute(resultGeo);
     resultGeo.computeVertexNormals();
     return resultGeo;
 }
@@ -709,6 +712,7 @@ function getModuleFaces(type, w, d, wh, rh, baseY, insets, baseW, baseD, tanThet
 function createGeometryFromFaces(faces, matRule = null) {
     const positions = [];
     const normals = [];
+    const uvs = [];
     const indices = [];
     const groups = [];
     let vertexCount = 0;
@@ -743,6 +747,9 @@ function createGeometryFromFaces(faces, matRule = null) {
             normals.push(normal.x, normal.y, normal.z);
             normals.push(normal.x, normal.y, normal.z);
             normals.push(normal.x, normal.y, normal.z);
+            pushRoofUv(uvs, p0, normal);
+            pushRoofUv(uvs, fi, normal);
+            pushRoofUv(uvs, fi1, normal);
             indices.push(vertexCount, vertexCount + 1, vertexCount + 2);
             faceVertexCount += 3;
             vertexCount += 3;
@@ -756,6 +763,7 @@ function createGeometryFromFaces(faces, matRule = null) {
     const geometry = new THREE.BufferGeometry();
     geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
     geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
     geometry.setIndex(indices);
     for (const g of groups) {
         geometry.addGroup(g.start, g.count, g.materialIndex);
@@ -763,5 +771,27 @@ function createGeometryFromFaces(faces, matRule = null) {
     // Merge identical vertices to optimize geometry for CSG and create clean topology
     const mergedGeo = mergeVertices(geometry, 1e-4);
     geometry.dispose();
+    ensureUv2Attribute(mergedGeo);
     return mergedGeo;
 }
+function pushRoofUv(uvs, point, normal) {
+    _uvFaceNormal.copy(normal).normalize();
+    const absX = Math.abs(_uvFaceNormal.x);
+    const absY = Math.abs(_uvFaceNormal.y);
+    const absZ = Math.abs(_uvFaceNormal.z);
+    if (absY >= absX && absY >= absZ) {
+        uvs.push(point.x, point.z);
+        return;
+    }
+    if (absX >= absZ) {
+        uvs.push(point.z, point.y);
+        return;
+    }
+    uvs.push(point.x, point.y);
+}
+function ensureUv2Attribute(geometry) {
+    const uv = geometry.getAttribute('uv');
+    if (!uv)
+        return;
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(uv.array), 2));
+}

package/dist/systems/slab/slab-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAOvD,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAuED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAG7E"}
+{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,cAAc,CAAA;AAcvD,eAAO,MAAM,UAAU,YAwBtB,CAAA;AAmFD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,cAAc,CAG7E"}