@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/shelf/floorplan-affordances.js

@@ -1,4 +1,4 @@
-import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { cascadeDirty, createSceneApi, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { isAngleSnapActive } from '@pascal-app/editor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance';
 // Mirror the 3D handles in `shelf/definition.ts` so a drag can't push a
@@ -32,7 +32,8 @@ export const shelfResizeAffordance = {
                     lastPatch = { depth: Math.max(MIN_SHELF_DEPTH, initialDepth + 2 * projDelta) };
                 }
                 useLiveNodeOverrides.getState().set(shelfId, lastPatch);
-                useScene.getState().markDirty(shelfId);
+                for (const id of cascadeDirty(shelfId, { scene: createSceneApi(useScene) }))
+                    useScene.getState().markDirty(id);
             },
             canCommit() {
                 return true;
@@ -79,7 +80,8 @@ export const shelfRotateAffordance = {
                 const newRotationY = initialRotationY - delta;
                 lastRotation = [r[0], newRotationY, r[2]];
                 useLiveNodeOverrides.getState().set(shelfId, { rotation: lastRotation });
-                useScene.getState().markDirty(shelfId);
+                for (const id of cascadeDirty(shelfId, { scene: createSceneApi(useScene) }))
+                    useScene.getState().markDirty(id);
             },
             canCommit() {
                 return true;

package/dist/shelf/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAqEnE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAsEnE,CAAA"}

package/dist/shelf/floorplan-move.js

@@ -1,4 +1,4 @@
-import { collectAlignmentAnchors, movingFootprintAnchors, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { cascadeDirty, collectAlignmentAnchors, createSceneApi, movingFootprintAnchors, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { applyFloorplanAlignment, getFloorStackPreviewPosition, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, triggerSFX, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
 /**
@@ -52,7 +52,8 @@ export const shelfFloorplanMoveTarget = ({ node, nodes }) => {
             });
             lastVisualPosition = visualPosition;
             useLiveNodeOverrides.getState().set(shelfId, { position: visualPosition });
-            useScene.getState().markDirty(shelfId);
+            for (const id of cascadeDirty(shelfId, { scene: createSceneApi(useScene) }))
+                useScene.getState().markDirty(id);
         },
         canCommit() {
             const live = useScene.getState().nodes[shelfId];

package/dist/shelf/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/shelf/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAA0B,MAAM,kBAAkB,CAAA;AAC/E,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAe,KAAK,EAAuB,MAAM,OAAO,CAAA;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAuFzC,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,EAClB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,GAClC,KAAK,CAkCP;AAySD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,CAM3D"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/shelf/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAe,KAAK,EAAuB,MAAM,OAAO,CAAA;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0EzC,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,EAClB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,GAClC,KAAK,CAkCP;AAySD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,CAM3D"}

package/dist/shelf/geometry.js

@@ -1,4 +1,4 @@
-import { getMaterialPresetByRef } from '@pascal-app/core';
+import { SHELF_BOARD_INSET as BOARD_INSET, getMaterialPresetByRef, shelfBoardDimensions, } from '@pascal-app/core';
 import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, resolveMaterialRef, } from '@pascal-app/viewer';
 import { BoxGeometry, Group, Mesh } from 'three';
 import { sanitizeShelfDimensions } from './dimensions';
@@ -27,14 +27,6 @@ function stampShelfSlot(mesh, slotId) {
     mesh.userData.slotId = slotId;
     return mesh;
 }
-// A board's front/back faces land on the frame's outer faces (posts / back panel)
-// — coplanar surfaces the depth buffer can't separate, which flickers as z-fighting.
-// Recess 1mm so the board sits just inside: the meshes still overlap (no gap), but
-// no faces are coplanar. Depth is always recessed (boards reach into the back panel
-// / posts). Width is recessed only at call sites where boards span OVER posts
-// (open-rack / no-sides bookshelf); boards that ABUT side panels keep full width so
-// they meet the sides flush — abutting faces are back-to-back and never fight.
-const BOARD_INSET = 0.001;
 // Frame members that pass under the top board (dividers / back / corner posts) reach
 // y=unitHeight, coplanar with the top board's top face → z-fighting. Drop their top 1mm so
 // the board cleanly caps them; their bottom stays on the floor.
@@ -44,7 +36,7 @@ function cappedFrameY(unitHeight) {
     return { height, centerY: height / 2 };
 }
 function boardGeometry(width, thickness, depth, insetWidth = false) {
-    return new BoxGeometry(insetWidth ? Math.max(width - 2 * BOARD_INSET, 0.001) : width, thickness, Math.max(depth - 2 * BOARD_INSET, 0.001));
+    return new BoxGeometry(...shelfBoardDimensions(width, thickness, depth, insetWidth));
 }
 export function buildShelfGeometry(rawNode, ctx, shading = 'rendered') {
     const node = sanitizeShelfDimensions(rawNode);

package/dist/shelf/parametrics.js

@@ -67,10 +67,10 @@ export const shelfParametrics = {
         {
             label: 'Dimensions',
             fields: [
-                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 3.0, step: 0.05 },
-                { key: 'depth', kind: 'number', unit: 'm', min: 0.1, max: 1.0, step: 0.05 },
-                { key: 'thickness', kind: 'number', unit: 'm', min: 0.01, max: 0.1, step: 0.005 },
-                { key: 'height', kind: 'number', unit: 'm', min: 0.05, max: 2.5, step: 0.05 },
+                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 1000, step: 0.05 },
+                { key: 'depth', kind: 'number', unit: 'm', min: 0.1, max: 1000, step: 0.05 },
+                { key: 'thickness', kind: 'number', unit: 'm', min: 0.01, max: 1000, step: 0.005 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.05, max: 1000, step: 0.05 },
             ],
         },
         {

package/dist/site/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/site/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,QAAQ,EAOd,MAAM,kBAAkB,CAAA;AAoHzB,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,uCAmRxD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/site/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,QAAQ,EAQd,MAAM,kBAAkB,CAAA;AA6HzB,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,uCAmSxD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/site/renderer.js

@@ -1,10 +1,10 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { terrainFieldOf, useLiveNodeOverrides, useLiveTerrain, useRegistry, useScene, } from '@pascal-app/core';
-import { backdropGradient, deepSkyColor, getSceneTheme, horizonHazeColor, NodeRenderer, unionPolygons, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { terrainFieldOf, unionPolygons, useLiveNodeOverrides, useLiveTerrain, useRegistry, useScene, } from '@pascal-app/core';
+import { backdropGradient, deepSkyColor, getSceneTheme, horizonHazeColor, NodeRenderer, useNodeEvents, useSceneAtmosphere, useSceneGroundReplacement, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef } from 'react';
 import { BufferAttribute, BufferGeometry, Path, Shape, ShapeGeometry } from 'three';
-import { cameraPosition, color, float, mix, positionWorld, smoothstep, vec2 } from 'three/tsl';
+import { cameraPosition, color, mix, positionWorld, smoothstep, float as tslFloat, vec2, } from 'three/tsl';
 import { MeshLambertNodeMaterial } from 'three/webgpu';
 import { getRecessedSlabGroundHoles } from './recessed-slab-ground-holes';
 import { buildDrapedPolyline, terrainGridKey, updateDrapedHeights, } from './terrain-drape';
@@ -75,6 +75,8 @@ function addSlabHoles(shape, slabPolygons, originX = 0, originZ = 0) {
 }
 export const SiteRenderer = ({ node }) => {
     const ref = useRef(null);
+    const atmosphere = useSceneAtmosphere();
+    const groundReplaced = useSceneGroundReplacement();
     useRegistry(node.id, 'site', ref);
     const bgColor = useViewer((state) => getSceneTheme(state.sceneTheme).ground);
     const backgroundColor = useViewer((state) => getSceneTheme(state.sceneTheme).background);
@@ -126,47 +128,56 @@ export const SiteRenderer = ({ node }) => {
         material.polygonOffsetUnits = 1;
         return material;
     }, [bgColor]);
-    // Presentation horizon: a large ground disc under the lot, in the same
-    // theme ground colour, fading radially into the theme background so the
-    // scene sits on an "infinite" plane that dissolves into the sky instead of
-    // a hard-edged plate floating on the backdrop. Never pickable.
+    // Presentation horizon: a large ground disc under the lot, fading into the
+    // active fog radiance (or the theme backdrop when there is no atmosphere) so
+    // the scene sits on an "infinite" plane instead of a hard-edged plate. Never pickable.
     const horizonMaterial = useMemo(() => {
-        if (!fadeBounds)
+        if (!fadeBounds || groundReplaced)
             return null;
         const material = new MeshLambertNodeMaterial({ color: bgColor });
         const center = vec2(fadeBounds.cx, fadeBounds.cz);
         const dist = positionWorld.xz.sub(center).length();
-        const fade = smoothstep(float(fadeBounds.radius * 1.05), float(fadeBounds.radius * 5), dist);
+        const fade = smoothstep(tslFloat(fadeBounds.radius * 1.05), tslFloat(fadeBounds.radius * 5), dist);
         // Contact vignette: a soft darkening that hugs the lot so the parcel
         // reads as sitting on the ground instead of floating on an even field.
         // The linear cut competes with the tone mapper's shoulder — bright themes
         // (studio's key light runs at intensity 4) compress a fixed 15% to almost
         // nothing — so the strength scales with the theme's strongest light.
         const vignetteStrength = Math.min(0.45, 0.13 * maxLightIntensity);
-        const halo = float(1)
-            .sub(smoothstep(float(fadeBounds.radius * 0.95), float(fadeBounds.radius * 2.6), dist))
+        const halo = tslFloat(1)
+            .sub(smoothstep(tslFloat(fadeBounds.radius * 0.95), tslFloat(fadeBounds.radius * 2.6), dist))
             .mul(vignetteStrength);
-        const haloFactor = float(1).sub(halo);
+        const haloFactor = tslFloat(1).sub(halo);
         material.colorNode = mix(color(bgColor), color('#000000'), fade).mul(haloFactor);
-        // Dissolve, not tint: the albedo (lighting response, incl. shadows) fades
-        // to black while an emissive term fades up to the backdrop gradient — the
-        // exact formula the post pipeline composites (viewer lib/backdrop.ts),
-        // evaluated with this fragment's view direction, so the far end is
-        // literally the backdrop (incl. the horizon haze) from any camera pose.
-        const viewDirY = positionWorld.sub(cameraPosition).normalize().y;
-        const backdrop = backdropGradient({
-            dirY: viewDirY,
-            background: color(backgroundColor),
-            haze: color(horizonHazeColor(skyColor, appearance)),
-            sky: color(skyColor),
-            skyDeep: color(deepSkyColor(skyColor)),
-        });
+        // Dissolve, not tint: albedo fades to black while emissive fades up to the
+        // exact active horizon source, evaluated with this fragment's world-space
+        // view direction. fogRadiance excludes celestial discs and stars so they
+        // cannot leave bright spots around the ground seam.
+        const viewDir = positionWorld.sub(cameraPosition).normalize();
+        const backdrop = atmosphere
+            ? atmosphere.fogRadiance(viewDir)
+            : backdropGradient({
+                dirY: viewDir.y,
+                background: color(backgroundColor),
+                haze: color(horizonHazeColor(skyColor, appearance)),
+                sky: color(skyColor),
+                skyDeep: color(deepSkyColor(skyColor)),
+            });
         material.emissiveNode = mix(color('#000000'), backdrop, fade).mul(haloFactor);
         material.polygonOffset = true;
         material.polygonOffsetFactor = 2;
         material.polygonOffsetUnits = 2;
         return material;
-    }, [bgColor, backgroundColor, skyColor, appearance, maxLightIntensity, fadeBounds]);
+    }, [
+        atmosphere,
+        bgColor,
+        backgroundColor,
+        skyColor,
+        appearance,
+        maxLightIntensity,
+        fadeBounds,
+        groundReplaced,
+    ]);
     // Cache computed polygons to keep the selector stable across unrelated store updates.
     const slabPolygonsCache = useRef([]);
     const slabPolygons = useScene((state) => {
@@ -195,7 +206,7 @@ export const SiteRenderer = ({ node }) => {
     //
     // biome-ignore lint/correctness/useExhaustiveDependencies: `terrainKey` is the grid signature the footprint is a function of; depending on the field itself would rebuild an 800 m disc every dab.
     const horizonGeometry = useMemo(() => {
-        if (!fadeBounds)
+        if (!fadeBounds || groundReplaced)
             return null;
         const radius = Math.max(fadeBounds.radius * 8, 400);
         const shape = new Shape();
@@ -209,8 +220,9 @@ export const SiteRenderer = ({ node }) => {
         const holes = terrainGrid ? [...slabPolygons, terrainFootprint(terrainGrid)] : slabPolygons;
         addSlabHoles(shape, holes, fadeBounds.cx, fadeBounds.cz);
         return new ShapeGeometry(shape);
-    }, [fadeBounds, slabPolygons, terrainKey]);
+    }, [fadeBounds, slabPolygons, terrainKey, groundReplaced]);
     useEffect(() => () => horizonGeometry?.dispose(), [horizonGeometry]);
+    useEffect(() => () => horizonMaterial?.dispose(), [horizonMaterial]);
     // Boundary line geometry, subdivided against the terrain grid when there is one.
     //
     // Keyed on `terrainKey`, not on the field: the crease set depends on the grid

package/dist/site/terrain-geometry.d.ts

@@ -18,7 +18,7 @@ import { type HeightPatch, type TerrainField } from '@pascal-app/core';
  *   (~1.5 ms at 257²), `computeVertexNormals()` rewrites the *whole* normal
  *   attribute, which silently defeats the dirty-rect partial upload that makes
  *   sculpting cheap. `normalAt` central-differences the field instead, so a
- *   patch touches only the rows it changed.
+ *   patch touches only its footprint and the neighbouring normals.
  * - **Vertices are one-per-sample and shared between triangles**, so a partial
  *   upload is a contiguous row range. Duplicating verts per-triangle for flat
  *   shading would triple memory and scatter the dirty range.

package/dist/site/terrain-geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terrain-geometry.d.ts","sourceRoot":"","sources":["../../src/site/terrain-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAA4B,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEhG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAAQ,CAAA;AAWpC,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gDAAgD;IAChD,SAAS,EAAE,YAAY,CAAA;IACvB,gDAAgD;IAChD,OAAO,EAAE,YAAY,CAAA;IACrB,+CAA+C;IAC/C,GAAG,EAAE,YAAY,CAAA;IACjB,2CAA2C;IAC3C,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAOD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,kBAAkB,CAkCxE;AA8BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,+EAA+E;IAC/E,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,EAAE,YAAY,CAAA;IACrB,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAY7E;AAwBD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,mBAAmB,CAsB1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAyB1F;AAmBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,GACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAWzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,WAAW,GACjB,IAAI,CASN"}
+{"version":3,"file":"terrain-geometry.d.ts","sourceRoot":"","sources":["../../src/site/terrain-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAA4B,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEhG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAAQ,CAAA;AAWpC,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gDAAgD;IAChD,SAAS,EAAE,YAAY,CAAA;IACvB,gDAAgD;IAChD,OAAO,EAAE,YAAY,CAAA;IACrB,+CAA+C;IAC/C,GAAG,EAAE,YAAY,CAAA;IACjB,2CAA2C;IAC3C,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAOD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,kBAAkB,CAkCxE;AA8BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,+EAA+E;IAC/E,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,EAAE,YAAY,CAAA;IACrB,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAY7E;AAwBD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,mBAAmB,CAsB1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAyB1F;AAmBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,GACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAoBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,WAAW,GACjB,IAAI,CA8BN"}

package/dist/site/terrain-geometry.js

@@ -18,7 +18,7 @@ import { heightAtSample, normalAt } from '@pascal-app/core';
  *   (~1.5 ms at 257²), `computeVertexNormals()` rewrites the *whole* normal
  *   attribute, which silently defeats the dirty-rect partial upload that makes
  *   sculpting cheap. `normalAt` central-differences the field instead, so a
- *   patch touches only the rows it changed.
+ *   patch touches only its footprint and the neighbouring normals.
  * - **Vertices are one-per-sample and shared between triangles**, so a partial
  *   upload is a contiguous row range. Duplicating verts per-triangle for flat
  *   shading would triple memory and scatter the dirty range.
@@ -228,10 +228,16 @@ function writeSkirtVertex(buffers, index, x, y, z, nx, nz) {
  * shading along the edit boundary.
  */
 export function patchUpdateRange(field, patch, itemSize) {
+    if (patch.cols <= 0 ||
+        patch.rows <= 0 ||
+        patch.col0 >= field.cols ||
+        patch.row0 >= field.rows ||
+        patch.col0 + patch.cols <= 0 ||
+        patch.row0 + patch.rows <= 0) {
+        return null;
+    }
     const firstRow = Math.max(0, patch.row0 - 1);
     const lastRow = Math.min(field.rows - 1, patch.row0 + patch.rows);
-    if (lastRow < firstRow)
-        return null;
     const startVertex = firstRow * field.cols;
     const endVertex = lastRow * field.cols + (field.cols - 1);
     return {
@@ -248,12 +254,32 @@ export function patchUpdateRange(field, patch, itemSize) {
  * whole point of the dirty-rect path.
  */
 export function updateTerrainMesh(field, buffers, patch) {
-    const firstRow = Math.max(0, patch.row0 - 1);
-    const lastRow = Math.min(field.rows - 1, patch.row0 + patch.rows);
-    for (let r = firstRow; r <= lastRow; r++) {
-        for (let c = 0; c < field.cols; c++) {
-            const i = r * field.cols + c;
-            writeVertex(field, buffers.positions, buffers.normals, buffers.uvs, c, r, i);
+    const col0 = Math.max(0, patch.col0);
+    const row0 = Math.max(0, patch.row0);
+    const col1 = Math.min(field.cols, patch.col0 + patch.cols);
+    const row1 = Math.min(field.rows, patch.row0 + patch.rows);
+    if (col0 >= col1 || row0 >= row1)
+        return;
+    for (let r = row0; r < row1; r++) {
+        for (let c = col0; c < col1; c++) {
+            buffers.positions[(r * field.cols + c) * 3 + 1] = heightAtSample(field, c, r);
+        }
+    }
+    // Uploads may span whole rows, but CPU work only needs the changed samples
+    // and the one-cell halo used by central-difference normals.
+    const firstCol = Math.max(0, col0 - 1);
+    const firstRow = Math.max(0, row0 - 1);
+    const lastCol = Math.min(field.cols, col1 + 1);
+    const lastRow = Math.min(field.rows, row1 + 1);
+    for (let r = firstRow; r < lastRow; r++) {
+        const z = field.origin[1] + r * field.spacing;
+        for (let c = firstCol; c < lastCol; c++) {
+            const x = field.origin[0] + c * field.spacing;
+            const [nx, ny, nz] = normalAt(field, x, z);
+            const i = (r * field.cols + c) * 3;
+            buffers.normals[i] = nx;
+            buffers.normals[i + 1] = ny;
+            buffers.normals[i + 2] = nz;
         }
     }
 }

package/dist/site/terrain-mesh.d.ts

@@ -21,6 +21,11 @@ import { type TerrainMeshBuffers, type TerrainSkirtBuffers } from './terrain-geo
 export type TerrainGeometry = {
     readonly geometry: BufferGeometry;
     readonly buffers: TerrainMeshBuffers;
+    /** Expands during live edits; a committed-field rebuild tightens it again. */
+    readonly heightBounds: {
+        minY: number;
+        maxY: number;
+    };
     /** The edge curtain that closes the field against the horizon disc. */
     readonly skirt: {
         readonly geometry: BufferGeometry;

package/dist/site/terrain-mesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terrain-mesh.d.ts","sourceRoot":"","sources":["../../src/site/terrain-mesh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACjE,OAAO,EAAmB,cAAc,EAAmB,MAAM,OAAO,CAAA;AACxE,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EAGzB,MAAM,oBAAoB,CAAA;AAE3B;;;;;;;;;;;;;;;GAeG;AAEH,0DAA0D;AAC1D,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;IACpC,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAA;KAAE,CAAA;CAC7F,CAAA;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,YAAY,GAAG,eAAe,CAoB1E;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,WAAW,GACjB,IAAI,CA0BN;AA8DD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAElF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAGpE"}
+{"version":3,"file":"terrain-mesh.d.ts","sourceRoot":"","sources":["../../src/site/terrain-mesh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACjE,OAAO,EAAmB,cAAc,EAA4B,MAAM,OAAO,CAAA;AACjF,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EAGzB,MAAM,oBAAoB,CAAA;AAE3B;;;;;;;;;;;;;;;GAeG;AAEH,0DAA0D;AAC1D,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;IACpC,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IACrD,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAA;KAAE,CAAA;CAC7F,CAAA;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,YAAY,GAAG,eAAe,CAsC1E;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,WAAW,GACjB,IAAI,CA6CN;AAuED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAElF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAGpE"}

package/dist/site/terrain-mesh.js

@@ -1,23 +1,29 @@
-import { BufferAttribute, BufferGeometry, Sphere, Vector3 } from 'three';
+import { BufferAttribute, BufferGeometry, DynamicDrawUsage, Sphere } from 'three';
 import { buildTerrainMesh, buildTerrainSkirt, HORIZON_PLANE_Y, patchUpdateRange, updateTerrainMesh, updateTerrainSkirt, } from './terrain-geometry';
 export function createTerrainGeometry(field) {
     const buffers = buildTerrainMesh(field);
     const geometry = new BufferGeometry();
-    geometry.setAttribute('position', new BufferAttribute(buffers.positions, 3));
-    geometry.setAttribute('normal', new BufferAttribute(buffers.normals, 3));
+    geometry.setAttribute('position', new BufferAttribute(buffers.positions, 3).setUsage(DynamicDrawUsage));
+    geometry.setAttribute('normal', new BufferAttribute(buffers.normals, 3).setUsage(DynamicDrawUsage));
     geometry.setAttribute('uv', new BufferAttribute(buffers.uvs, 2));
     geometry.setIndex(new BufferAttribute(buffers.indices, 1));
-    setTerrainBounds(geometry, field);
+    const span = heightSpan(field);
+    setTerrainBounds(geometry, field, span);
     // A separate geometry, not extra vertices on the surface: the surface's dirty
     // range is a row span over a `cols * rows` layout, and appending a perimeter ring
     // to it would break that indexing for a saving of one draw call.
     const skirtBuffers = buildTerrainSkirt(field);
     const skirtGeometry = new BufferGeometry();
-    skirtGeometry.setAttribute('position', new BufferAttribute(skirtBuffers.positions, 3));
-    skirtGeometry.setAttribute('normal', new BufferAttribute(skirtBuffers.normals, 3));
+    skirtGeometry.setAttribute('position', new BufferAttribute(skirtBuffers.positions, 3).setUsage(DynamicDrawUsage));
+    skirtGeometry.setAttribute('normal', new BufferAttribute(skirtBuffers.normals, 3).setUsage(DynamicDrawUsage));
     skirtGeometry.setIndex(new BufferAttribute(skirtBuffers.indices, 1));
-    setSkirtBounds(skirtGeometry, field);
-    return { geometry, buffers, skirt: { geometry: skirtGeometry, buffers: skirtBuffers } };
+    setSkirtBounds(skirtGeometry, field, span);
+    return {
+        geometry,
+        buffers,
+        heightBounds: span,
+        skirt: { geometry: skirtGeometry, buffers: skirtBuffers },
+    };
 }
 /**
  * Push one patch to the GPU, touching only the affected rows.
@@ -28,49 +34,72 @@ export function createTerrainGeometry(field) {
  * grid indices, not heights.
  */
 export function applyTerrainPatch(target, field, patch) {
-    updateTerrainMesh(field, target.buffers, patch);
-    // The skirt goes up unconditionally, before the range bail: a patch that leaves
-    // the surface's dirty span empty can still have moved a boundary sample, and a
-    // stale skirt is a hole at the property line.
-    updateTerrainSkirt(field, target.skirt.buffers);
-    for (const name of ['position', 'normal']) {
-        const attribute = target.skirt.geometry.getAttribute(name);
-        attribute.needsUpdate = true;
-    }
-    setSkirtBounds(target.skirt.geometry, field);
     const range = patchUpdateRange(field, patch, 3);
     if (!range)
         return;
+    updateTerrainMesh(field, target.buffers, patch);
+    if (patch.col0 <= 0 ||
+        patch.row0 <= 0 ||
+        patch.col0 + patch.cols >= field.cols ||
+        patch.row0 + patch.rows >= field.rows) {
+        updateTerrainSkirt(field, target.skirt.buffers);
+        for (const name of ['position', 'normal']) {
+            const attribute = target.skirt.geometry.getAttribute(name);
+            attribute.needsUpdate = true;
+        }
+    }
     for (const name of ['position', 'normal']) {
         const attribute = target.geometry.getAttribute(name);
-        // `clearUpdateRanges` first: ranges accumulate, so a stroke dabbing 60 times
-        // a second would otherwise grow an unbounded list that all gets re-uploaded.
+        let start = range.start;
+        let end = start + range.count;
+        // Only the renderer knows when an upload happened. Keep all dabs since then.
+        for (const pending of attribute.updateRanges) {
+            start = Math.min(start, pending.start);
+            end = Math.max(end, pending.start + pending.count);
+        }
         attribute.clearUpdateRanges();
-        attribute.addUpdateRange(range.start, range.count);
+        attribute.addUpdateRange(start, end - start);
         attribute.needsUpdate = true;
     }
-    setTerrainBounds(target.geometry, field);
+    // Keep bounds conservative while brushing: removing an old extreme need not
+    // rescan the field, while a new extreme must become visible immediately.
+    const span = target.heightBounds;
+    const col0 = Math.max(0, patch.col0);
+    const row0 = Math.max(0, patch.row0);
+    const col1 = Math.min(field.cols, patch.col0 + patch.cols);
+    const row1 = Math.min(field.rows, patch.row0 + patch.rows);
+    for (let row = row0; row < row1; row++) {
+        for (let col = col0; col < col1; col++) {
+            const height = (field.heights[row * field.cols + col] ?? 0) * field.step;
+            span.minY = Math.min(span.minY, height);
+            span.maxY = Math.max(span.maxY, height);
+        }
+    }
+    setTerrainBounds(target.geometry, field, span);
+    setSkirtBounds(target.skirt.geometry, field, span);
 }
 /**
  * Set bounds analytically instead of calling `computeBoundingSphere()`.
  *
  * The computed version walks every vertex twice and allocates; the field's
  * horizontal extent is known in O(1) from `origin`/`spacing`/`cols`/`rows`, and
- * only the height range needs a scan. Skipping bounds entirely is not an option —
+ * the height range is scanned once, then expanded from patches. Skipping bounds
+ * entirely is not an option —
  * a stale bounding sphere gets a raised hill frustum-culled while it is still on
  * screen, which reads as terrain flickering out at certain camera angles.
  */
-function setTerrainBounds(geometry, field) {
-    const { minY, maxY } = heightSpan(field);
+function setTerrainBounds(geometry, field, { minY, maxY }) {
     const minX = field.origin[0];
     const minZ = field.origin[1];
     const maxX = minX + (field.cols - 1) * field.spacing;
     const maxZ = minZ + (field.rows - 1) * field.spacing;
-    const center = new Vector3((minX + maxX) / 2, (minY + maxY) / 2, (minZ + maxZ) / 2);
-    const radius = Math.hypot((maxX - minX) / 2, (maxY - minY) / 2, (maxZ - minZ) / 2);
-    geometry.boundingSphere = new Sphere(center, radius);
+    geometry.boundingSphere ??= new Sphere();
+    const sphere = geometry.boundingSphere;
+    sphere.center.set((minX + maxX) / 2, (minY + maxY) / 2, (minZ + maxZ) / 2);
+    sphere.radius = Math.hypot((maxX - minX) / 2, (maxY - minY) / 2, (maxZ - minZ) / 2);
     if (geometry.boundingBox) {
-        geometry.boundingBox.set(new Vector3(minX, minY, minZ), new Vector3(maxX, maxY, maxZ));
+        geometry.boundingBox.min.set(minX, minY, minZ);
+        geometry.boundingBox.max.set(maxX, maxY, maxZ);
     }
 }
 /**
@@ -81,17 +110,17 @@ function setTerrainBounds(geometry, field) {
  * avoid, one geometry over. The vertical span brackets the horizon plane for the
  * same reason the geometry does.
  */
-function setSkirtBounds(geometry, field) {
-    const { minY, maxY } = heightSpan(field);
+function setSkirtBounds(geometry, field, { minY, maxY }) {
     const low = Math.min(minY, HORIZON_PLANE_Y) - 1;
     const high = Math.max(maxY, HORIZON_PLANE_Y);
     const minX = field.origin[0];
     const minZ = field.origin[1];
     const maxX = minX + (field.cols - 1) * field.spacing;
     const maxZ = minZ + (field.rows - 1) * field.spacing;
-    const center = new Vector3((minX + maxX) / 2, (low + high) / 2, (minZ + maxZ) / 2);
-    const radius = Math.hypot((maxX - minX) / 2, (high - low) / 2, (maxZ - minZ) / 2);
-    geometry.boundingSphere = new Sphere(center, radius);
+    geometry.boundingSphere ??= new Sphere();
+    const sphere = geometry.boundingSphere;
+    sphere.center.set((minX + maxX) / 2, (low + high) / 2, (minZ + maxZ) / 2);
+    sphere.radius = Math.hypot((maxX - minX) / 2, (high - low) / 2, (maxZ - minZ) / 2);
 }
 /** Height span in metres, always including the datum so flat ground has a box. */
 function heightSpan(field) {

package/dist/skylight/definition.js

@@ -246,7 +246,7 @@ export const skylightDefinition = {
     presentation: {
         label: 'Skylight',
         description: 'Framed glass opening on a roof segment.',
-        icon: { kind: 'url', src: '/icons/roof.webp' },
+        icon: { kind: 'url', src: '/icons/skylight.webp' },
         paletteSection: 'structure',
         paletteOrder: 124,
     },

package/dist/skylight/panel.js

@@ -218,7 +218,7 @@ export default function SkylightPanel() {
                             return (_jsx("button", { className: cn('flex min-h-12 items-center gap-2.5 rounded-lg border px-3 py-2.5 text-left text-xs transition-colors', isSelected
                                     ? 'border-orange-400/60 bg-orange-400/10 text-foreground'
                                     : 'border-border/50 bg-[#2C2C2E] text-muted-foreground hover:bg-[#3e3e3e] hover:text-foreground'), onClick: () => handleTypeChange(skylightType), type: "button", children: _jsx("span", { className: "min-w-0 truncate font-medium", children: SKYLIGHT_TYPE_PRESETS[skylightType].label }) }, skylightType));
-                        }) }), _jsx(SliderControl, { label: "Glass Thickness", max: 0.05, min: 0.002, onChange: (v) => previewProp({ glassThickness: v }), onCommit: (v) => commitProp({ glassThickness: v }), precision: 3, restoreOnCommit: false, step: 0.001, unit: "m", value: Math.round((node.glassThickness ?? 0.01) * 1000) / 1000 }), activeSkylightType === 'lantern' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Lantern Height", max: 1.0, min: 0.05, onChange: (v) => previewProp({ lanternHeight: v }), onCommit: (v) => commitProp({ lanternHeight: v }), precision: 3, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((node.lanternHeight ?? 0.25) * 1000) / 1000 }), _jsx(SliderControl, { label: "Top Scale", max: 0.95, min: 0, onChange: (v) => previewProp({ lanternTopScale: v }), onCommit: (v) => commitProp({ lanternTopScale: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "", value: Math.round((node.lanternTopScale ?? 0.25) * 100) / 100 })] })), activeSkylightType === 'opening' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Open", max: 1, min: 0, onChange: (v) => previewProp({ operationState: v }), onCommit: (v) => commitProp({ operationState: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "", value: Math.round((node.operationState ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Opening Angle", max: 80, min: 0, onChange: (deg) => previewProp({ openingAngle: (deg * Math.PI) / 180 }), onCommit: (deg) => commitProp({ openingAngle: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.openingAngle ?? Math.PI / 10) * 180) / Math.PI) }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ openingSide: v }), options: [
+                        }) }), _jsx(SliderControl, { label: "Glass Thickness", max: 0.05, min: 0.002, onChange: (v) => previewProp({ glassThickness: v }), onCommit: (v) => commitProp({ glassThickness: v }), precision: 3, restoreOnCommit: false, step: 0.001, unit: "m", value: node.glassThickness ?? 0.01 }), activeSkylightType === 'lantern' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Lantern Height", max: 1.0, min: 0.05, onChange: (v) => previewProp({ lanternHeight: v }), onCommit: (v) => commitProp({ lanternHeight: v }), precision: 3, restoreOnCommit: false, step: 0.01, unit: "m", value: node.lanternHeight ?? 0.25 }), _jsx(SliderControl, { label: "Top Scale", max: 0.95, min: 0, onChange: (v) => previewProp({ lanternTopScale: v }), onCommit: (v) => commitProp({ lanternTopScale: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "", value: Math.round((node.lanternTopScale ?? 0.25) * 100) / 100 })] })), activeSkylightType === 'opening' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Open", max: 1, min: 0, onChange: (v) => previewProp({ operationState: v }), onCommit: (v) => commitProp({ operationState: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "", value: Math.round((node.operationState ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Opening Angle", max: 80, min: 0, onChange: (deg) => previewProp({ openingAngle: (deg * Math.PI) / 180 }), onCommit: (deg) => commitProp({ openingAngle: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.openingAngle ?? Math.PI / 10) * 180) / Math.PI) }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ openingSide: v }), options: [
                                     { label: 'Top', value: 'top' },
                                     { label: 'Bottom', value: 'bottom' },
                                     { label: 'Left', value: 'left' },
@@ -226,23 +226,23 @@ export default function SkylightPanel() {
                                 ], value: (node.openingSide ?? 'top') }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ motorHousing: v === 'yes' }), options: [
                                     { label: 'Motor', value: 'yes' },
                                     { label: 'No Motor', value: 'no' },
-                                ], value: (node.motorHousing ?? false) ? 'yes' : 'no' }), (node.motorHousing ?? false) && (_jsx(SliderControl, { label: "Motor Housing", max: 0.2, min: 0.03, onChange: (v) => previewProp({ motorHousingSize: v }), onCommit: (v) => commitProp({ motorHousingSize: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.motorHousingSize ?? 0.08) * 1000) / 1000 }))] })), activeSkylightType === 'sliding' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Open", max: 1, min: 0, onChange: (v) => previewProp({ operationState: v }), onCommit: (v) => commitProp({ operationState: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "", value: Math.round((node.operationState ?? 0) * 100) / 100 }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ slideDirection: v }), options: [
+                                ], value: (node.motorHousing ?? false) ? 'yes' : 'no' }), (node.motorHousing ?? false) && (_jsx(SliderControl, { label: "Motor Housing", max: 0.2, min: 0.03, onChange: (v) => previewProp({ motorHousingSize: v }), onCommit: (v) => commitProp({ motorHousingSize: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.motorHousingSize ?? 0.08 }))] })), activeSkylightType === 'sliding' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Open", max: 1, min: 0, onChange: (v) => previewProp({ operationState: v }), onCommit: (v) => commitProp({ operationState: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "", value: Math.round((node.operationState ?? 0) * 100) / 100 }), _jsx(SegmentedControl, { onChange: (v) => commitProp({ slideDirection: v }), options: [
                                     { label: 'Along Z', value: 'z' },
                                     { label: 'Along X', value: 'x' },
-                                ], value: (node.slideDirection ?? 'z') }), _jsx(SliderControl, { label: "Track Width", max: 0.12, min: 0.02, onChange: (v) => previewProp({ trackWidth: v }), onCommit: (v) => commitProp({ trackWidth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.trackWidth ?? 0.045) * 1000) / 1000 })] }))] }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: 3, min: 0.3, onChange: (v) => previewProp({ width: v }), onCommit: (v) => commitProp({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.width * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 3, min: 0.3, onChange: (v) => previewProp({ height: v }), onCommit: (v) => commitProp({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.height * 100) / 100 })] }), _jsxs(PanelSection, { title: "Frame", children: [_jsx(SliderControl, { label: "Thickness", max: 0.2, min: 0.02, onChange: (v) => previewProp({ frameThickness: v }), onCommit: (v) => commitProp({ frameThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.frameThickness ?? 0.05) * 1000) / 1000 }), _jsx(SliderControl, { label: "Depth", max: 0.3, min: 0.02, onChange: (v) => previewProp({ frameDepth: v }), onCommit: (v) => commitProp({ frameDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.frameDepth ?? 0.08) * 1000) / 1000 }), _jsx(SliderControl, { label: "Cutout Offset", max: 0.2, min: 0, onChange: (v) => previewProp({ cutoutOffset: v }), onCommit: (v) => commitProp({ cutoutOffset: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.cutoutOffset ?? 0.01) * 1000) / 1000 })] }), _jsxs(PanelSection, { title: "Curb", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ curb: v === 'yes' }), options: [
+                                ], value: (node.slideDirection ?? 'z') }), _jsx(SliderControl, { label: "Track Width", max: 0.12, min: 0.02, onChange: (v) => previewProp({ trackWidth: v }), onCommit: (v) => commitProp({ trackWidth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.trackWidth ?? 0.045 })] }))] }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: 1000, min: 0.3, onChange: (v) => previewProp({ width: v }), onCommit: (v) => commitProp({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.width }), _jsx(SliderControl, { label: "Height", max: 1000, min: 0.3, onChange: (v) => previewProp({ height: v }), onCommit: (v) => commitProp({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.height })] }), _jsxs(PanelSection, { title: "Frame", children: [_jsx(SliderControl, { label: "Thickness", max: 0.2, min: 0.02, onChange: (v) => previewProp({ frameThickness: v }), onCommit: (v) => commitProp({ frameThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.frameThickness ?? 0.05 }), _jsx(SliderControl, { label: "Depth", max: 0.3, min: 0.02, onChange: (v) => previewProp({ frameDepth: v }), onCommit: (v) => commitProp({ frameDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.frameDepth ?? 0.08 }), _jsx(SliderControl, { label: "Cutout Offset", max: 0.2, min: 0, onChange: (v) => previewProp({ cutoutOffset: v }), onCommit: (v) => commitProp({ cutoutOffset: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.cutoutOffset ?? 0.01 })] }), _jsxs(PanelSection, { title: "Curb", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ curb: v === 'yes' }), options: [
                             { label: 'Yes', value: 'yes' },
                             { label: 'No', value: 'no' },
-                        ], value: (node.curb ?? false) ? 'yes' : 'no' }), (node.curb ?? false) && (_jsx(SliderControl, { label: "Height", max: 0.3, min: 0.02, onChange: (v) => previewProp({ curbHeight: v }), onCommit: (v) => commitProp({ curbHeight: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.curbHeight ?? 0.1) * 1000) / 1000 }))] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(worldMaxX * 10) / 10, min: Math.round(worldMinX * 10) / 10, onChange: (newWorldX) => {
+                        ], value: (node.curb ?? false) ? 'yes' : 'no' }), (node.curb ?? false) && (_jsx(SliderControl, { label: "Height", max: 0.3, min: 0.02, onChange: (v) => previewProp({ curbHeight: v }), onCommit: (v) => commitProp({ curbHeight: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.curbHeight ?? 0.1 }))] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(worldMaxX * 10) / 10, min: Math.round(worldMinX * 10) / 10, onChange: (newWorldX) => {
                             if (!segment)
                                 return;
                             const local = worldToSegLocal(newWorldX, worldZ_now, segment);
                             previewProp({ position: [local.localX, 0, local.localZ] });
-                        }, onCommit: (newWorldX) => commitWorldPosition(newWorldX, worldZ_now), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(worldX_now * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: Math.round(worldMaxZ * 10) / 10, min: Math.round(worldMinZ * 10) / 10, onChange: (newWorldZ) => {
+                        }, onCommit: (newWorldX) => commitWorldPosition(newWorldX, worldZ_now), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: worldX_now }), _jsx(SliderControl, { label: "Z", max: Math.round(worldMaxZ * 10) / 10, min: Math.round(worldMinZ * 10) / 10, onChange: (newWorldZ) => {
                             if (!segment)
                                 return;
                             const local = worldToSegLocal(worldX_now, newWorldZ, segment);
                             previewProp({ position: [local.localX, 0, local.localZ] });
-                        }, onCommit: (newWorldZ) => commitWorldPosition(worldX_now, newWorldZ), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(worldZ_now * 100) / 100 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (degrees) => {
+                        }, onCommit: (newWorldZ) => commitWorldPosition(worldX_now, newWorldZ), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: worldZ_now }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (degrees) => {
                             const newWorldRot = (degrees * Math.PI) / 180;
                             if (!skylightObj)
                                 return;

package/dist/skylight/parametrics.js

@@ -15,8 +15,8 @@ export const skylightParametrics = {
         {
             label: 'Dimensions',
             fields: [
-                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 3, step: 0.05 },
-                { key: 'height', kind: 'number', unit: 'm', min: 0.3, max: 3, step: 0.05 },
+                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 1000, step: 0.05 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.3, max: 1000, step: 0.05 },
                 { key: 'frameThickness', kind: 'number', unit: 'm', min: 0.02, max: 0.15, step: 0.005 },
                 { key: 'frameDepth', kind: 'number', unit: 'm', min: 0.02, max: 0.2, step: 0.005 },
                 { key: 'glassThickness', kind: 'number', unit: 'm', min: 0.005, max: 0.05, step: 0.001 },

package/dist/slab/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AA0BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsNnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAiH1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AA4BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsNnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAsH1D,CAAA"}

package/dist/slab/definition.js

@@ -1,5 +1,5 @@
 import { MIN_SLAB_THICKNESS, markSlabChangeDependents, pointInPolygon2D, syncStairRises, } from '@pascal-app/core';
-import { clearStructuralElevationGuide, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
 import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
 import { applySlabBaseElevationChange, applySlabThicknessChange, applySlabTopChange, getSlabBaseElevation, slabElevationUpperBound, } from './elevation-limit';
 import { buildSlabFloorplan } from './floorplan';
@@ -197,6 +197,11 @@ export const slabDefinition = {
     schema: SlabNode,
     category: 'structure',
     surfaceRole: 'floor',
+    extensions: {
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'slab',
+        },
+    },
     defaults: () => ({
         object: 'node',
         parentId: null,

package/dist/slab/dependency-tracker.d.ts

@@ -0,0 +1,3 @@
+import { type AnyNode, type AnyNodeId } from '@pascal-app/core';
+export declare function createSlabDependencyTracker(initialNodes: Record<string, AnyNode>): (nodes: Record<string, AnyNode>) => AnyNodeId[];
+//# sourceMappingURL=dependency-tracker.d.ts.map

package/dist/slab/dependency-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-tracker.d.ts","sourceRoot":"","sources":["../../src/slab/dependency-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAQf,MAAM,kBAAkB,CAAA;AAmBzB,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAwBxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,SAAS,EAAE,CAwF7D"}