@pascal-app/viewer 0.9.1 → 0.9.2

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

@@ -1,5 +1,22 @@
 import { type FenceNode } from '@pascal-app/core';
 import * as THREE from 'three';
+type FencePart = {
+    geometry?: THREE.BufferGeometry;
+    position: [number, number, number];
+    rotationY?: number;
+    scale: [number, number, number];
+    shape?: 'box' | 'pyramid';
+};
+export type FenceSlotId = 'posts' | 'infill' | 'base' | 'rail';
+export type FenceSlotParts = Record<FenceSlotId, FencePart[]>;
+/**
+ * Geometry split by paint slot — posts, infill, base, rail — each a separate
+ * merged BufferGeometry (empty ones included) so the fence renderer can give
+ * each its own material + `userData.slotId`. Slots match the panel's build
+ * options 1:1.
+ */
+export declare function generateFenceSlotGeometries(fence: FenceNode): Record<FenceSlotId, THREE.BufferGeometry>;
 export declare function generateFenceGeometry(fence: FenceNode): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
 export declare const FenceSystem: () => null;
+export {};
 //# sourceMappingURL=fence-system.d.ts.map

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":"AAAA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA2O9B,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,oFAcrD;AAgBD,eAAO,MAAM,WAAW,YAiBvB,CAAA"}
+{"version":3,"file":"fence-system.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,KAAK,SAAS,GAAG;IACf,QAAQ,CAAC,EAAE,KAAK,CAAC,cAAc,CAAA;IAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAG/B,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;CAC1B,CAAA;AAqPD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;AAE9D,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,WAAW,EAAE,SAAS,EAAE,CAAC,CAAA;AAsQ7D;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,GACf,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,cAAc,CAAC,CAQ3C;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,oFAGrD;AAgBD,eAAO,MAAM,WAAW,YAiBvB,CAAA"}

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

@@ -1,10 +1,16 @@
-import { getWallCurveFrameAt, getWallCurveLength, sceneRegistry, useScene, } from '@pascal-app/core';
+import { getFenceCenterlineFrameAt, getFenceCenterlineLength, sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 const MIN_CURVE_SEGMENT_LENGTH = 0.18;
+const HORIZONTAL_FENCE_CURVE_SEGMENT_LENGTH = 0.2;
 function createFencePartGeometry(part) {
-    const geometry = new THREE.BoxGeometry(1, 1, 1);
+    if (part.geometry) {
+        return part.geometry;
+    }
+    const geometry = part.shape === 'pyramid'
+        ? new THREE.ConeGeometry(0.5, 1, 4, 1, false, Math.PI / 4)
+        : new THREE.BoxGeometry(1, 1, 1);
     geometry.scale(part.scale[0], part.scale[1], part.scale[2]);
     if (part.rotationY) {
         geometry.rotateY(part.rotationY);
@@ -14,37 +20,79 @@ function createFencePartGeometry(part) {
     return geometry;
 }
 function getFencePointAt(fence, t) {
-    const frame = getWallCurveFrameAt(fence, t);
+    const frame = getFenceCenterlineFrameAt(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) {
+function createFenceCurveBlockPart(fence, startT, endT, centerY, height, depth) {
+    if (endT - startT <= 1e-5)
         return null;
+    const halfHeight = height / 2;
+    const halfDepth = depth / 2;
+    const centerlineLength = getFenceCenterlineLength(fence);
+    const startDistance = startT * centerlineLength;
+    const endDistance = endT * centerlineLength;
+    const bottomY = centerY - halfHeight;
+    const topY = centerY + halfHeight;
+    const corners = [];
+    for (const t of [startT, endT]) {
+        const frame = getFencePointAt(fence, t);
+        const normalX = -Math.sin(frame.tangentAngle);
+        const normalZ = Math.cos(frame.tangentAngle);
+        const outerX = frame.point.x + normalX * halfDepth;
+        const outerZ = frame.point.y + normalZ * halfDepth;
+        const innerX = frame.point.x - normalX * halfDepth;
+        const innerZ = frame.point.y - normalZ * halfDepth;
+        corners.push([outerX, bottomY, outerZ], [innerX, bottomY, innerZ], [outerX, topY, outerZ], [innerX, topY, innerZ]);
     }
+    const positions = [];
+    const uvs = [];
+    const pushVertex = (index, uv) => {
+        positions.push(...corners[index]);
+        uvs.push(...uv);
+    };
+    const pushQuad = (a, b, c, d, uvA, uvB, uvC, uvD) => {
+        pushVertex(a, uvA);
+        pushVertex(b, uvB);
+        pushVertex(c, uvC);
+        pushVertex(a, uvA);
+        pushVertex(c, uvC);
+        pushVertex(d, uvD);
+    };
+    const topOuterV = topY;
+    const topInnerV = topY + depth;
+    const innerTopV = topInnerV;
+    const innerBottomV = topInnerV + height;
+    const bottomInnerV = bottomY - depth;
+    pushQuad(0, 4, 6, 2, [startDistance, bottomY], [endDistance, bottomY], [endDistance, topY], [startDistance, topY]);
+    pushQuad(1, 3, 7, 5, [startDistance, innerBottomV], [startDistance, innerTopV], [endDistance, innerTopV], [endDistance, innerBottomV]);
+    pushQuad(2, 6, 7, 3, [startDistance, topOuterV], [endDistance, topOuterV], [endDistance, topInnerV], [startDistance, topInnerV]);
+    pushQuad(0, 1, 5, 4, [startDistance, bottomY], [startDistance, bottomInnerV], [endDistance, bottomInnerV], [endDistance, bottomY]);
+    pushQuad(0, 2, 3, 1, [0, bottomY], [0, topY], [depth, innerTopV], [depth, innerBottomV]);
+    pushQuad(4, 5, 7, 6, [0, bottomY], [depth, innerBottomV], [depth, innerTopV], [0, topY]);
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(positions), 3));
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(new Float32Array(uvs), 2));
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(new Float32Array(uvs), 2));
+    geometry.computeVertexNormals();
     return {
-        position: [(start[0] + end[0]) / 2, centerY, (start[1] + end[1]) / 2],
-        rotationY: -Math.atan2(dz, dx),
-        scale: [length, height, depth],
+        geometry,
+        position: [0, 0, 0],
+        scale: [1, 1, 1],
     };
 }
-function createFenceCurveSpanParts(fence, startT, endT, centerY, height, depth) {
+function createFenceCurveBlockParts(fence, startT, endT, centerY, height, depth, maxSegmentLength = MIN_CURVE_SEGMENT_LENGTH) {
+    const length = getFenceCenterlineLength(fence) * Math.max(1e-4, endT - startT);
+    const segmentCount = Math.max(1, Math.ceil(length / Math.max(1e-4, maxSegmentLength)));
     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;
+    for (let index = 0; index < segmentCount; index += 1) {
+        const segmentStartT = startT + (endT - startT) * (index / segmentCount);
+        const segmentEndT = startT + (endT - startT) * ((index + 1) / segmentCount);
+        const part = createFenceCurveBlockPart(fence, segmentStartT, segmentEndT, centerY, height, depth);
+        if (part)
+            parts.push(part);
     }
     return parts;
 }
@@ -53,15 +101,13 @@ function applyFenceUVs(geometry) {
     const normal = geometry.getAttribute('normal');
     if (!(position && normal))
         return;
+    // World-scale triplanar UVs: 1 UV unit = 1 metre, sampled from the part's
+    // local-space (already translated into fence space) coordinates with NO
+    // per-part origin shift. A shared origin keeps a tiled finish continuous
+    // across posts, rails, and infill instead of restarting the tile at each
+    // part's own min corner (the previous behaviour, which broke the 1 m
+    // contract and made adjacent parts mistile).
     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);
@@ -72,16 +118,16 @@ function applyFenceUVs(geometry) {
         let u = 0;
         let v = 0;
         if (ny >= nx && ny >= nz) {
-            u = px - minX;
-            v = pz - minZ;
+            u = px;
+            v = pz;
         }
         else if (nx >= nz) {
-            u = pz - minZ;
-            v = py - minY;
+            u = pz;
+            v = py;
         }
         else {
-            u = px - minX;
-            v = py - minY;
+            u = px;
+            v = py;
         }
         uvs[index * 2] = u;
         uvs[index * 2 + 1] = v;
@@ -98,9 +144,104 @@ function getStyleDefaults(style) {
     }
     return { spacingFactor: 0.3, postFactor: 0.55, baseFactor: 1, topFactor: 0.75 };
 }
+/**
+ * Horizontal-board fence — composite cladding boards stacked between square
+ * intermediate posts (each capped), instead of the vertical pickets the other
+ * styles draw. Posts march along the whole span at `postSpacing` (not just the
+ * two ends), the boards run full-length so they curve with the fence, and a
+ * thin reveal between boards leaves the groove shadow that reads as cladding.
+ */
+function createHorizontalFenceParts(fence) {
+    const posts = [];
+    const infill = [];
+    const base = [];
+    const rail = [];
+    const length = Math.max(getFenceCenterlineLength(fence), 0.01);
+    const panelDepth = Math.max(fence.thickness, 0.03);
+    const clearance = Math.max(fence.groundClearance, 0);
+    const isFloating = fence.baseStyle === 'floating';
+    const showInfill = fence.showInfill ?? true;
+    const baseHeight = Math.max(fence.baseHeight, 0.04);
+    const topRailHeight = Math.max(fence.topRailHeight, 0.01);
+    const verticalHeight = Math.max(fence.height - baseHeight - topRailHeight, 0.08);
+    const baseY = isFloating ? clearance : 0;
+    // Square posts stand proud of the recessed boards on both faces.
+    const postWidth = Math.max(fence.postSize * 1.4, 0.04);
+    const postDepth = postWidth;
+    const boardDepth = Math.min(panelDepth, postDepth - 0.012);
+    // Stop the horizontal boards / base / rail at the inner faces of the
+    // end posts. Letting curved spans run all the way to t=0/1 makes them
+    // overlap the terminal post mesh and creates the broken seam/notch seen
+    // at curve ends.
+    const edgeInset = Math.max(fence.edgeInset ?? 0.015, postWidth * 0.5);
+    const startInsetT = Math.min(0.499, edgeInset / length);
+    const endInsetT = Math.max(0.501, 1 - edgeInset / length);
+    // Grounded fences get a kickboard along the bottom; floating ones don't.
+    if (!isFloating) {
+        base.push(...createFenceCurveBlockParts(fence, startInsetT, endInsetT, baseY + baseHeight / 2, baseHeight, postDepth * 0.92, HORIZONTAL_FENCE_CURVE_SEGMENT_LENGTH));
+    }
+    // Stack full-length boards between the kickboard and the top rail. The board
+    // height is derived to evenly fill the panel around a ~0.145 m target, with a
+    // constant reveal between each so the count adapts to any fence height.
+    if (showInfill) {
+        const reveal = Math.max(fence.slatGap ?? 0.01, 0);
+        const infillBottom = baseY + baseHeight;
+        if (reveal < 0.002) {
+            // No reveal → one flush panel, so the stacked-board edge seams don't
+            // read as faint lines where the user asked for a smooth surface.
+            infill.push(...createFenceCurveBlockParts(fence, startInsetT, endInsetT, infillBottom + verticalHeight / 2, verticalHeight, boardDepth, HORIZONTAL_FENCE_CURVE_SEGMENT_LENGTH));
+        }
+        else {
+            const boardCount = Math.max(1, Math.round(verticalHeight / (0.145 + reveal)));
+            const slabHeight = Math.max((verticalHeight - reveal * (boardCount - 1)) / boardCount, 0.02);
+            for (let index = 0; index < boardCount; index += 1) {
+                const centerY = infillBottom + slabHeight / 2 + index * (slabHeight + reveal);
+                infill.push(...createFenceCurveBlockParts(fence, startInsetT, endInsetT, centerY, slabHeight, boardDepth, HORIZONTAL_FENCE_CURVE_SEGMENT_LENGTH));
+            }
+        }
+    }
+    // Top rail caps the boards.
+    rail.push(...createFenceCurveBlockParts(fence, startInsetT, endInsetT, baseY + baseHeight + verticalHeight + topRailHeight / 2, topRailHeight, Math.max(postDepth * 0.78, 0.02), HORIZONTAL_FENCE_CURVE_SEGMENT_LENGTH));
+    // Posts at every `postSpacing`, anchored at both ends, each with a flat cap.
+    const spacing = Math.max(fence.postSpacing, postWidth * 1.4);
+    const postCount = Math.max(2, Math.floor(length / spacing) + 1);
+    const postHeight = baseHeight + verticalHeight + topRailHeight + clearance;
+    const capHeight = Math.max(postWidth * 0.32, 0.03);
+    const cap = fence.postCap ?? 'pyramid';
+    for (let index = 0; index < postCount; index += 1) {
+        const t = postCount === 1 ? 0.5 : index / (postCount - 1);
+        const frame = getFencePointAt(fence, t);
+        posts.push({
+            position: [frame.point.x, postHeight / 2, frame.point.y],
+            rotationY: -frame.tangentAngle,
+            scale: [postWidth, postHeight, postDepth],
+        });
+        if (cap === 'flat') {
+            posts.push({
+                position: [frame.point.x, postHeight + capHeight / 2, frame.point.y],
+                rotationY: -frame.tangentAngle,
+                scale: [postWidth * 1.22, capHeight, postDepth * 1.22],
+            });
+        }
+        else if (cap === 'pyramid') {
+            posts.push({
+                position: [frame.point.x, postHeight + capHeight * 0.9, frame.point.y],
+                rotationY: -frame.tangentAngle,
+                scale: [postWidth * 1.18, capHeight * 1.8, postDepth * 1.18],
+                shape: 'pyramid',
+            });
+        }
+    }
+    return { posts, infill, base, rail };
+}
 function createFenceParts(fence) {
-    const parts = [];
-    const length = Math.max(getWallCurveLength(fence), 0.01);
+    if (fence.style === 'horizontal')
+        return createHorizontalFenceParts(fence);
+    const posts = [];
+    const infill = [];
+    const base = [];
+    const rail = [];
+    const length = Math.max(getFenceCenterlineLength(fence), 0.01);
     const panelDepth = Math.max(fence.thickness, 0.03);
     const clearance = Math.max(fence.groundClearance, 0);
     const styleDefaults = getStyleDefaults(fence.style);
@@ -117,34 +258,42 @@ function createFenceParts(fence) {
     const startInsetT = Math.min(0.499, edgeInset / length);
     const endInsetT = Math.max(0.501, 1 - edgeInset / length);
     if (!isFloating) {
-        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));
+        base.push(...createFenceCurveBlockParts(fence, 0, 1, baseY + effectiveBaseHeight / 2, effectiveBaseHeight, panelDepth * 1.05));
+        base.push(...createFenceCurveBlockParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight * 0.15, topRailHeight * 0.8, panelDepth * 0.35));
     }
     const count = showInfill ? Math.max(2, Math.floor((length - edgeInset * 2) / spacing) + 1) : 2;
     const verticalY = baseY + effectiveBaseHeight + verticalHeight / 2;
     for (let index = 0; index < count; index += 1) {
         const t = count === 1 ? 0.5 : startInsetT + (endInsetT - startInsetT) * (index / (count - 1));
-        const frame = getFencePointAt(fence, t);
         const isEdgePost = index === 0 || index === count - 1;
         const fullHeightPost = !showInfill || (isFloating && isEdgePost);
         const postHeight = fullHeightPost
             ? effectiveBaseHeight + verticalHeight + topRailHeight + clearance
             : verticalHeight;
         const postY = fullHeightPost ? postHeight / 2 : verticalY;
-        parts.push({
-            position: [frame.point.x, postY, frame.point.y],
-            rotationY: -frame.tangentAngle,
-            scale: [postWidth, postHeight, Math.max(panelDepth * 0.35, 0.012)],
-        });
+        // End posts are the structural `posts` slot; the intermediate verticals are
+        // the `infill` slats (only present when showInfill adds them).
+        const slatHalfT = Math.max(0.0005, postWidth / (2 * length));
+        const slatStartT = Math.max(0, t - slatHalfT);
+        const slatEndT = Math.min(1, t + slatHalfT);
+        const slat = createFenceCurveBlockPart(fence, slatStartT, slatEndT, postY, postHeight, Math.max(panelDepth * 0.35 - 0.001, 0.011));
+        if (slat) {
+            ;
+            (isEdgePost ? posts : infill).push(slat);
+        }
     }
-    parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
+    rail.push(...createFenceCurveBlockParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
     if (isFloating) {
-        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
+        rail.push(...createFenceCurveBlockParts(fence, 0, 1, baseY + effectiveBaseHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
     }
-    return parts;
+    return { posts, infill, base, rail };
 }
-export function generateFenceGeometry(fence) {
-    const parts = createFenceParts(fence);
+function mergeFenceParts(parts) {
+    // An empty slot group (e.g. infill with showInfill off, or base on a floating
+    // fence) must not reach mergeGeometries — it throws on an empty array. The
+    // empty geometry has no position attribute, so the renderer skips its mesh.
+    if (parts.length === 0)
+        return new THREE.BufferGeometry();
     const geometries = parts.map(createFencePartGeometry);
     const merged = mergeGeometries(geometries, false) ?? new THREE.BufferGeometry();
     geometries.forEach((geometry) => {
@@ -157,9 +306,28 @@ export function generateFenceGeometry(fence) {
     merged.computeVertexNormals();
     return merged;
 }
+/**
+ * Geometry split by paint slot — posts, infill, base, rail — each a separate
+ * merged BufferGeometry (empty ones included) so the fence renderer can give
+ * each its own material + `userData.slotId`. Slots match the panel's build
+ * options 1:1.
+ */
+export function generateFenceSlotGeometries(fence) {
+    const parts = createFenceParts(fence);
+    return {
+        posts: mergeFenceParts(parts.posts),
+        infill: mergeFenceParts(parts.infill),
+        base: mergeFenceParts(parts.base),
+        rail: mergeFenceParts(parts.rail),
+    };
+}
+export function generateFenceGeometry(fence) {
+    const { posts, infill, base, rail } = createFenceParts(fence);
+    return mergeFenceParts([...posts, ...infill, ...base, ...rail]);
+}
 function updateFenceGeometry(fenceId) {
     const node = useScene.getState().nodes[fenceId];
-    if (!node || node.type !== 'fence')
+    if (node?.type !== 'fence')
         return;
     const mesh = sceneRegistry.nodes.get(fenceId);
     if (!mesh)
@@ -179,7 +347,7 @@ export const FenceSystem = () => {
         const nodes = useScene.getState().nodes;
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
-            if (!node || node.type !== 'fence')
+            if (node?.type !== 'fence')
                 return;
             updateFenceGeometry(id);
             clearDirty(id);

package/dist/systems/geometry/geometry-system.d.ts

@@ -1,3 +1,4 @@
+import { type Group, type Object3D } from 'three';
 /**
  * Generic geometry system.
  *
@@ -31,4 +32,10 @@
  */
 export declare const GeometrySystem: () => null;
 export default GeometrySystem;
+export type GeometryBuildCacheEntry = {
+    group: Group;
+    key: string;
+};
+export declare function markGeometryBuildOutput(child: Object3D): void;
+export declare function shouldReuseGeometryBuild(cache: Map<string, GeometryBuildCacheEntry>, id: string, group: Group, key: string): boolean;
 //# sourceMappingURL=geometry-system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"geometry-system.d.ts","sourceRoot":"","sources":["../../../src/systems/geometry/geometry-system.tsx"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,cAAc,YAwK1B,CAAA;AAyHD,eAAe,cAAc,CAAA"}
+{"version":3,"file":"geometry-system.d.ts","sourceRoot":"","sources":["../../../src/systems/geometry/geometry-system.tsx"],"names":[],"mappings":"AAeA,OAAO,EAAa,KAAK,KAAK,EAA4B,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAQtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,cAAc,YA8L1B,CAAA;AAmJD,eAAe,cAAc,CAAA;AAE7B,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,KAAK,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAU7D;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC3C,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GACV,OAAO,CAKT"}

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

@@ -1,5 +1,5 @@
 'use client';
-import { getEffectiveNode, nodeRegistry, sceneRegistry, useScene, } from '@pascal-app/core';
+import { getEffectiveNode, nodeRegistry, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { FrontSide } from 'three';
@@ -43,11 +43,24 @@ export const GeometrySystem = () => {
     const textures = useViewer((s) => s.textures);
     const colorPreset = useViewer((s) => s.colorPreset);
     const sceneTheme = useViewer((s) => s.sceneTheme);
+    const bumpGeometryRevision = useViewer((s) => s.bumpGeometryRevision);
+    // The shared scene-material library, threaded into each builder's ctx so
+    // pure geometry builders can resolve `scene:<id>` slot refs without
+    // importing `useScene`.
+    const sceneMaterials = useScene((s) => s.materials);
     // Per-node cache of the last-built geometry key (for kinds that declare
     // `def.geometryKey`). Lets us skip a dispose+rebuild when a node is dirty
     // but its geometry inputs are unchanged — e.g. an item reparenting onto a
     // shelf dirties the shelf without altering its boards.
     const builtGeometryKeyRef = useRef(new Map());
+    // Re-mark every geometry-backed node dirty whenever a viewer appearance
+    // value changes, so `def.geometry` builders re-run and pick up the new
+    // shading / texture / preset / theme. These four are deliberate re-run
+    // TRIGGERS, not values read in the body — the effect re-fires on any
+    // change. They're primitives (stable by value), so listing them is safe;
+    // biome flags them as "unnecessary" because the body doesn't reference
+    // them, but dropping them silently breaks appearance-mode switching.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: shading/textures/colorPreset/sceneTheme are intentional re-run triggers; removing them stops geometry from rebuilding on appearance change.
     useEffect(() => {
         const nodes = useScene.getState().nodes;
         for (const node of Object.values(nodes)) {
@@ -57,10 +70,30 @@ export const GeometrySystem = () => {
             }
         }
     }, [shading, textures, colorPreset, sceneTheme]);
+    // Editing a scene material must re-colour every geometry node that
+    // references it through a `scene:<id>` slot ref. Such a node's
+    // `geometryKey` is unchanged (only the referenced material's contents
+    // moved), so clear its cached key to defeat the skip in the rebuild loop,
+    // then mark it dirty. Scoped to nodes carrying a `scene:` ref so an
+    // unrelated material edit doesn't churn the whole scene.
+    useEffect(() => {
+        void sceneMaterials;
+        const nodes = useScene.getState().nodes;
+        for (const node of Object.values(nodes)) {
+            const def = nodeRegistry.get(node.type);
+            if (!def?.geometry)
+                continue;
+            if (!nodeReferencesSceneMaterial(node))
+                continue;
+            builtGeometryKeyRef.current.delete(node.id);
+            useScene.getState().markDirty(node.id);
+        }
+    }, [sceneMaterials]);
     useFrame(() => {
         if (dirtyNodes.size === 0)
             return;
         const nodes = useScene.getState().nodes;
+        let rebuiltGeometry = false;
         const batches = new Map();
         const dirtyIds = [];
         dirtyNodes.forEach((id) => {
@@ -132,17 +165,17 @@ export const GeometrySystem = () => {
             // never skipped. This kills the board remount + pointer enter/leave
             // churn when an item reparents onto a shelf.
             if (def.geometryKey) {
-                const builtKey = `${shading}|${textures}|${colorPreset}|${sceneTheme}|${def.geometryKey(effectiveNode)}`;
-                if (builtGeometryKeyRef.current.get(id) === builtKey) {
+                const childLiveOverrideKey = liveChildOverrideKey(node);
+                const builtKey = `${shading}|${textures}|${colorPreset}|${sceneTheme}|${def.geometryKey(effectiveNode)}|${childLiveOverrideKey}`;
+                if (shouldReuseGeometryBuild(builtGeometryKeyRef.current, id, group, builtKey)) {
                     clearDirty(id);
                     continue;
                 }
-                builtGeometryKeyRef.current.set(id, builtKey);
             }
             const parentId = (node.parentId ?? null);
             const key = `${node.type}::${parentId ?? ''}`;
             const levelData = levelDataByBatch.get(key);
-            const ctx = buildGeometryContext(effectiveNode, nodes, levelData);
+            const ctx = buildGeometryContext(effectiveNode, nodes, levelData, sceneMaterials);
             // The builder is typed against the kind's specific node — at the
             // generic system level we lose that refinement, so the cast lands
             // here. Builders are responsible for trusting their schema.
@@ -152,22 +185,10 @@ export const GeometrySystem = () => {
             }
             disposeChildren(group);
             for (const child of [...built.children]) {
-                // Tag every child the builder produced so a subsequent rebuild
-                // can dispose only THIS rebuild's outputs and leave React-
-                // mounted siblings (hosted items inside a shelf / slab / etc.)
-                // alone. Without this, a parent rebuild triggered by a child
-                // event (e.g. an item reparenting onto a shelf calls
-                // `dirtyNodes.add(parent)` in `ItemRenderer`'s effect) would
-                // wipe ALL of the parent group's children — including the
-                // freshly-mounted item — leaving the item in scene state but
-                // invisible.
-                ;
-                child.userData = {
-                    ...child.userData,
-                    __fromGeometry: true,
-                };
+                markGeometryBuildOutput(child);
                 group.add(child);
             }
+            rebuiltGeometry = true;
             // NOTE: we intentionally do NOT reset `group.position` / `group.rotation`
             // here. The `ParametricNodeRenderer` binds them via JSX (`position={...}`
             // / `rotation={...}`) driven by `useLiveTransforms` during drag and
@@ -178,17 +199,45 @@ export const GeometrySystem = () => {
             // origin. Geometry builders are expected to emit local-space children.
             clearDirty(id);
         }
+        if (rebuiltGeometry)
+            bumpGeometryRevision();
     }, 2);
     return null;
 };
-function buildGeometryContext(node, nodes, levelData) {
-    const resolve = (id) => nodes[id];
+function liveChildOverrideKey(node) {
+    const childIds = node.children;
+    if (!Array.isArray(childIds) || childIds.length === 0)
+        return '';
+    const overrides = useLiveNodeOverrides.getState().overrides;
+    const entries = [];
+    for (const childId of childIds) {
+        const override = overrides.get(childId);
+        if (override)
+            entries.push([childId, override]);
+    }
+    return entries.length === 0 ? '' : JSON.stringify(entries);
+}
+function nodeReferencesSceneMaterial(node) {
+    const slots = node.slots;
+    if (!slots)
+        return false;
+    for (const ref of Object.values(slots)) {
+        if (typeof ref === 'string' && ref.startsWith('scene:'))
+            return true;
+    }
+    return false;
+}
+function buildGeometryContext(node, nodes, levelData, materials) {
+    const resolve = (id) => {
+        const resolved = nodes[id];
+        return resolved ? getEffectiveNode(resolved) : undefined;
+    };
     const childIds = node.children;
     const children = Array.isArray(childIds)
-        ? childIds.map((cid) => nodes[cid]).filter((n) => n !== undefined)
+        ? childIds.map((cid) => resolve(cid)).filter((n) => n !== undefined)
         : [];
     const parentId = node.parentId;
-    const parent = parentId ? (nodes[parentId] ?? null) : null;
+    const parent = parentId ? (resolve(parentId) ?? null) : null;
     // Siblings = same kind, same parent, excluding self. Walks the parent's
     // children array; falls back to scanning the whole scene if the parent
     // doesn't carry a `children` list (rare — most parents do).
@@ -199,16 +248,18 @@ function buildGeometryContext(node, nodes, levelData) {
             for (const sid of parentChildIds) {
                 if (sid === node.id)
                     continue;
-                const s = nodes[sid];
+                const s = resolve(sid);
                 if (s && s.type === node.type)
                     siblings.push(s);
             }
         }
         else {
-            siblings = Object.values(nodes).filter((n) => n !== node && n.type === node.type && n.parentId === parentId);
+            siblings = Object.values(nodes)
+                .filter((n) => n !== node && n.type === node.type && n.parentId === parentId)
+                .map((n) => getEffectiveNode(n));
         }
     }
-    return { resolve, children, siblings, parent, levelData };
+    return { resolve, children, siblings, parent, levelData, materials };
 }
 function disposeChildren(group) {
     // Only dispose meshes the geometry builder produced on the previous
@@ -277,3 +328,21 @@ function isCachedMaterial(value) {
         ?.__pascalCachedMaterial);
 }
 export default GeometrySystem;
+export function markGeometryBuildOutput(child) {
+    // Tag the builder subtree so paint previews can reach nested meshes (for
+    // example a cabinet sink faucet handle), while disposal still removes only
+    // top-level builder children from the registered group.
+    child.traverse((object) => {
+        object.userData = {
+            ...object.userData,
+            __fromGeometry: true,
+        };
+    });
+}
+export function shouldReuseGeometryBuild(cache, id, group, key) {
+    const cached = cache.get(id);
+    if (cached?.group === group && cached.key === key)
+        return true;
+    cache.set(id, { group, key });
+    return false;
+}

package/dist/systems/geometry/geometry-system.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=geometry-system.test.d.ts.map

package/dist/systems/geometry/geometry-system.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-system.test.d.ts","sourceRoot":"","sources":["../../../src/systems/geometry/geometry-system.test.ts"],"names":[],"mappings":""}

package/dist/systems/geometry/geometry-system.test.js

@@ -0,0 +1,30 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { BoxGeometry, Group, Mesh, MeshBasicMaterial } from 'three';
+import { markGeometryBuildOutput, shouldReuseGeometryBuild, } from './geometry-system';
+describe('markGeometryBuildOutput', () => {
+    test('marks nested builder meshes for slot paint preview', () => {
+        const root = new Group();
+        const nested = new Group();
+        const mesh = new Mesh(new BoxGeometry(1, 1, 1), new MeshBasicMaterial());
+        mesh.userData.slotId = 'appliance';
+        nested.add(mesh);
+        root.add(nested);
+        markGeometryBuildOutput(root);
+        expect(root.userData.__fromGeometry).toBe(true);
+        expect(nested.userData.__fromGeometry).toBe(true);
+        expect(mesh.userData.__fromGeometry).toBe(true);
+        expect(mesh.userData.slotId).toBe('appliance');
+    });
+});
+describe('shouldReuseGeometryBuild', () => {
+    test('rebuilds when the same node id remounts into a new group with the same key', () => {
+        const cache = new Map();
+        const firstGroup = new Group();
+        const remountedGroup = new Group();
+        expect(shouldReuseGeometryBuild(cache, 'duct_1', firstGroup, 'same-key')).toBe(false);
+        expect(shouldReuseGeometryBuild(cache, 'duct_1', firstGroup, 'same-key')).toBe(true);
+        expect(shouldReuseGeometryBuild(cache, 'duct_1', remountedGroup, 'same-key')).toBe(false);
+    });
+});