@pascal-app/viewer 1.0.1 → 1.0.4

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

@@ -10,7 +10,7 @@ export declare const DOUBLE_HUNG_BOTTOM_SASH_NAME = "double-hung-bottom-sash";
 export declare const LOUVERED_WINDOW_SLATS_NAME = "louvered-window-slats";
 export declare const AWNING_WINDOW_SASH_NAME = "awning-window-sash";
 export declare const HOPPER_WINDOW_SASH_NAME = "hopper-window-sash";
-export declare const pendingWindowAnimationRebuilds: Set<`building_${string}` | `level_${string}` | `elevator_${string}` | `unit_${string}` | `block_${string}` | `ceiling_${string}` | `item_${string}` | `procedural-item_${string}` | `column_${string}` | `construction-dimension_${string}` | `wall_${string}` | `roof_${string}` | `slab_${string}` | `fence_${string}` | `structural-grid_${string}` | `imesh_${string}` | `zone_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}` | `site_${string}` | `leanto_${string}` | `door_${string}` | `window_${string}` | `cabinet_${string}` | `cabinet-module_${string}` | `rseg_${string}` | `sseg_${string}` | `bvent_${string}` | `rvent_${string}` | `tvent_${string}` | `cupola_${string}` | `eyebrow-vent_${string}` | `gutter_${string}` | `chimney_${string}` | `solarpanel_${string}` | `skylight_${string}` | `dormer_${string}` | `downspout_${string}`>;
+export declare const pendingWindowAnimationRebuilds: Set<`building_${string}` | `level_${string}` | `elevator_${string}` | `unit_${string}` | `block_${string}` | `ceiling_${string}` | `item_${string}` | `procedural-item_${string}` | `column_${string}` | `construction-dimension_${string}` | `wall_${string}` | `roof_${string}` | `slab_${string}` | `separator_${string}` | `floor-opening_${string}` | `fence_${string}` | `structural-grid_${string}` | `imesh_${string}` | `zone_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}` | `site_${string}` | `leanto_${string}` | `door_${string}` | `window_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `cabinet_${string}` | `cabinet-module_${string}` | `rseg_${string}` | `sseg_${string}` | `bvent_${string}` | `rvent_${string}` | `tvent_${string}` | `cupola_${string}` | `eyebrow-vent_${string}` | `gutter_${string}` | `chimney_${string}` | `solarpanel_${string}` | `skylight_${string}` | `dormer_${string}` | `downspout_${string}`>;
 export declare const WindowSystem: () => null;
 /**
  * Build a fresh window mesh for preview/ghost rendering.

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

@@ -1 +1 @@
-{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAYL,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAyB9B,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,8BAA8B,8BAA8B,CAAA;AACzE,eAAO,MAAM,+BAA+B,+BAA+B,CAAA;AAC3E,eAAO,MAAM,gCAAgC,gCAAgC,CAAA;AAC7E,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAS3D,eAAO,MAAM,8BAA8B,uoCAAuB,CAAA;AAElE,eAAO,MAAM,YAAY,YAoHxB,CAAA;AA28GD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,IAAI,CAInE"}
+{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAcL,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA2B9B,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,8BAA8B,8BAA8B,CAAA;AACzE,eAAO,MAAM,+BAA+B,+BAA+B,CAAA;AAC3E,eAAO,MAAM,gCAAgC,gCAAgC,CAAA;AAC7E,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAS3D,eAAO,MAAM,8BAA8B,gvCAAuB,CAAA;AAElE,eAAO,MAAM,YAAY,YAuHxB,CAAA;AA29GD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,IAAI,CAInE"}

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

@@ -1,10 +1,11 @@
-import { DEFAULT_WALL_THICKNESS, getEffectiveNode, getWallThickness, sceneRegistry, useInteractive, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { DEFAULT_WALL_THICKNESS, getEffectiveNode, getOpeningWallPlacement, getWallThickness, sceneRegistry, scriptedSize, useInteractive, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
 import { applyWorldScaleBoxUVs } from '../../lib/box-uv';
-import { createSurfaceRoleMaterial, glassMaterial as defaultGlassMaterial, baseMaterial as getBaseMaterial, resolveMaterialRef, } from '../../lib/materials';
+import { createMaterial, createSurfaceRoleMaterial, glassMaterial as defaultGlassMaterial, baseMaterial as getBaseMaterial, resolveMaterialRef, } from '../../lib/materials';
 import { timeSpan } from '../../lib/perf-tracks';
+import { settleScriptedOpening } from '../../lib/scripted-opening';
 import useViewer from '../../store/use-viewer';
 import { getOpeningCutoutProxyDepth } from '../wall/opening-cutout-geometry';
 // Invisible material for root mesh — used as selection hitbox only
@@ -128,16 +129,20 @@ export const WindowSystem = () => {
             // Merge any live override (width / height / position) so the mesh
             // rebuild reflects the in-flight drag without zustand churn.
             const effectiveNode = getEffectiveNode(node);
-            timeSpan('window', () => updateWindowMesh(effectiveNode, mesh), {
+            const built = timeSpan('window', () => updateWindowMesh(effectiveNode, mesh), {
                 properties: [['node', id]],
             });
+            // A scripted opening stays dirty until its artifact has loaded.
+            if (!built)
+                continue;
             clearDirty(id);
             rebuiltWindowsThisFrame += 1;
             // Rebuild the parent wall so its cutout reflects the updated window geometry
             // Avoid triggering expensive wall CSG rebuilds while the window is being interactively moved/duplicated.
             // The editor tools will request a final wall rebuild on commit.
-            const isTransient = !!node.metadata?.isTransient;
-            if (!isTransient && effectiveNode.parentId) {
+            const metadata = effectiveNode.metadata;
+            const deferParentRebuild = !!metadata?.isTransient || !!metadata?.deferParentRebuild;
+            if (!deferParentRebuild && effectiveNode.parentId) {
                 useScene.getState().dirtyNodes.add(effectiveNode.parentId);
             }
         }
@@ -191,16 +196,19 @@ function windowSlotDefault(slotId) {
         getBaseMaterial(currentShading));
 }
 // Resolve a window's slot to a material: the `node.slots` override (colored mode
-// only) → the role/base default. Textures-off ignores overrides — the monochrome
-// escape hatch.
+// only) → the window-wide `material` for the frame (glass keeps its own) → the
+// role/base default. Textures-off ignores overrides — the monochrome escape hatch.
 function resolveWindowSlotMaterial(node, slotId) {
     const fallback = windowSlotDefault(slotId);
     if (!currentTextures)
         return fallback;
     const ref = node.slots?.[slotId];
-    if (!ref)
-        return fallback;
-    return resolveMaterialRef(ref, currentSceneMaterials, currentShading) ?? fallback;
+    const painted = ref ? resolveMaterialRef(ref, currentSceneMaterials, currentShading) : null;
+    if (painted)
+        return painted;
+    if (node.material && slotId === 'frame')
+        return createMaterial(node.material, currentShading);
+    return fallback;
 }
 function addBox(parent, material, w, h, d, x, y, z) {
     const geometry = new THREE.BoxGeometry(w, h, d);
@@ -1525,8 +1533,19 @@ function updateWindowMesh(node, mesh) {
     mesh.geometry = new THREE.BoxGeometry(node.width, node.height, node.frameDepth);
     mesh.material = hitboxMaterial;
     // Sync transform from node (React may lag behind the system by a frame during drag)
-    mesh.position.set(node.position[0], node.position[1], node.position[2]);
-    mesh.rotation.set(node.rotation[0], node.rotation[1], node.rotation[2]);
+    const parent = node.parentId ? useScene.getState().nodes[node.parentId] : undefined;
+    const placement = parent?.type === 'wall' && !node.roofSegmentId
+        ? getOpeningWallPlacement(getEffectiveNode(parent), node, useScene.getState().nodes)
+        : node;
+    mesh.position.set(...placement.position);
+    mesh.rotation.set(...placement.rotation);
+    // Built from a script: the renderer shows its artifact, not the parametric
+    // frame, and the hit box is what the script built.
+    if (node.source) {
+        mesh.geometry.dispose();
+        mesh.geometry = new THREE.BoxGeometry(...scriptedSize(node.source.manifest));
+        return settleScriptedOpening(mesh);
+    }
     // Dispose and remove all old visual children; preserve 'cutout'
     for (const child of [...mesh.children]) {
         if (child.name === 'cutout')
@@ -1542,62 +1561,62 @@ function updateWindowMesh(node, mesh) {
     const { width, height, frameDepth, frameThickness, columnRatios, rowRatios, columnDividerThickness, rowDividerThickness, sill, sillDepth, sillThickness, openingKind, openingShape, windowType, } = node;
     if (openingKind === 'opening') {
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (windowType === 'sliding') {
         addSlidingWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (windowType === 'casement') {
         addCasementWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (windowType === 'awning') {
         addAwningWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (windowType === 'hopper') {
         addAwningWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (windowType === 'single-hung') {
         addSingleHungWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (windowType === 'double-hung') {
         addDoubleHungWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (windowType === 'bay') {
         addBayWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (windowType === 'bow') {
         addBowWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (windowType === 'louvered') {
         addLouveredWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (openingShape === 'arch') {
         addArchedWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     if (openingShape === 'rounded') {
         addRoundedWindowVisuals(node, mesh);
         syncWindowCutout(node, mesh);
-        return;
+        return true;
     }
     const innerW = width - 2 * frameThickness;
     const innerH = height - 2 * frameThickness;
@@ -1672,6 +1691,7 @@ function updateWindowMesh(node, mesh) {
         addBox(mesh, baseMaterial, sillW, sillThickness, sillDepth, 0, -height / 2 - sillThickness / 2, sillZ);
     }
     syncWindowCutout(node, mesh);
+    return true;
 }
 function syncWindowCutout(node, mesh) {
     // ── Cutout: invisible raycast hit target for the whole opening ──

package/dist/xr/presentation-context.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+export declare function ImmersiveXRPresentationProvider({ children, enabled, }: {
+    children: ReactNode;
+    enabled: boolean;
+}): import("react").JSX.Element;
+export declare function useImmersiveXRPresentation(): boolean;
+//# sourceMappingURL=presentation-context.d.ts.map

package/dist/xr/presentation-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation-context.d.ts","sourceRoot":"","sources":["../../src/xr/presentation-context.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,SAAS,EAAc,MAAM,OAAO,CAAA;AAIjE,wBAAgB,+BAA+B,CAAC,EAC9C,QAAQ,EACR,OAAO,GACR,EAAE;IACD,QAAQ,EAAE,SAAS,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;CACjB,+BAMA;AAED,wBAAgB,0BAA0B,YAEzC"}

package/dist/xr/presentation-context.js

@@ -0,0 +1,10 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+const ImmersiveXRPresentationContext = createContext(false);
+export function ImmersiveXRPresentationProvider({ children, enabled, }) {
+    return (_jsx(ImmersiveXRPresentationContext.Provider, { value: enabled, children: children }));
+}
+export function useImmersiveXRPresentation() {
+    return useContext(ImmersiveXRPresentationContext);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/viewer",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "3D viewer component for Pascal building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,7 +33,7 @@
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.1",
+    "@pascal-app/core": "^1.0.4",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
@@ -46,12 +46,12 @@
     "zustand": "^5"
   },
   "devDependencies": {
-    "@pascal-app/core": "^1.0.1",
+    "@pascal-app/core": "^1.0.4",
     "@pascal/typescript-config": "*",
     "@react-three/test-renderer": "^9.1.0",
     "@types/node": "^22",
-    "@types/react": "^19.2.2",
-    "@types/react-dom": "19.2.2",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
     "@types/three": "^0.184.0",
     "typescript": "6.0.3"
   },
@@ -67,7 +67,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/pascalorg/editor.git",
+    "url": "git+https://github.com/pascalorg/editor.git",
     "directory": "packages/viewer"
   },
   "license": "MIT",

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

@@ -1,22 +0,0 @@
-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 +0,0 @@
-{"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,357 +0,0 @@
-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) {
-    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);
-    }
-    geometry.translate(part.position[0], part.position[1], part.position[2]);
-    applyFenceUVs(geometry);
-    return geometry;
-}
-function getFencePointAt(fence, t) {
-    const frame = getFenceCenterlineFrameAt(fence, t);
-    return {
-        point: frame.point,
-        tangentAngle: Math.atan2(frame.tangent.y, frame.tangent.x),
-    };
-}
-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 {
-        geometry,
-        position: [0, 0, 0],
-        scale: [1, 1, 1],
-    };
-}
-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 = [];
-    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;
-}
-function applyFenceUVs(geometry) {
-    const position = geometry.getAttribute('position');
-    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);
-    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;
-            v = pz;
-        }
-        else if (nx >= nz) {
-            u = pz;
-            v = py;
-        }
-        else {
-            u = px;
-            v = py;
-        }
-        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 };
-    }
-    if (style === 'rail') {
-        return { spacingFactor: 0.68, postFactor: 0.8, baseFactor: 0.85, topFactor: 0.85 };
-    }
-    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) {
-    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);
-    const baseHeight = Math.max(fence.baseHeight * styleDefaults.baseFactor, 0.04);
-    const topRailHeight = Math.max(fence.topRailHeight * styleDefaults.topFactor, 0.01);
-    const verticalHeight = Math.max(fence.height - baseHeight - topRailHeight, 0.08);
-    const postWidth = Math.max(fence.postSize * styleDefaults.postFactor, 0.01);
-    const spacing = Math.max(fence.postSpacing * styleDefaults.spacingFactor, postWidth * 1.2);
-    const edgeInset = Math.max(fence.edgeInset ?? 0.015, 0.005);
-    const isFloating = fence.baseStyle === 'floating';
-    const showInfill = fence.showInfill ?? true;
-    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) {
-        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 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;
-        // 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);
-        }
-    }
-    rail.push(...createFenceCurveBlockParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
-    if (isFloating) {
-        rail.push(...createFenceCurveBlockParts(fence, 0, 1, baseY + effectiveBaseHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
-    }
-    return { posts, infill, base, rail };
-}
-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) => {
-        geometry.dispose();
-    });
-    const mergedUv = merged.getAttribute('uv');
-    if (mergedUv) {
-        merged.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(mergedUv.array), 2));
-    }
-    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?.type !== 'fence')
-        return;
-    const mesh = sceneRegistry.nodes.get(fenceId);
-    if (!mesh)
-        return;
-    const newGeometry = generateFenceGeometry(node);
-    mesh.geometry.dispose();
-    mesh.geometry = newGeometry;
-    mesh.position.set(0, 0, 0);
-    mesh.rotation.set(0, 0, 0);
-}
-export const FenceSystem = () => {
-    const dirtyNodes = useScene((state) => state.dirtyNodes);
-    const clearDirty = useScene((state) => state.clearDirty);
-    useFrame(() => {
-        if (dirtyNodes.size === 0)
-            return;
-        const nodes = useScene.getState().nodes;
-        dirtyNodes.forEach((id) => {
-            const node = nodes[id];
-            if (node?.type !== 'fence')
-                return;
-            updateFenceGeometry(id);
-            clearDirty(id);
-        });
-    }, 4);
-    return null;
-};