@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

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

@@ -229,7 +229,7 @@ export default function SkylightPanel() {
                                 ], 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: [
                                     { 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: Math.round((node.trackWidth ?? 0.045) * 1000) / 1000 })] }))] }), _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: Math.round(node.width * 100) / 100 }), _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: 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: [
                             { 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) => {

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"}

package/dist/slab/dependency-tracker.js

@@ -0,0 +1,104 @@
+import { getRenderableSlabPolygon, prepareSlabPolygonContext, scopeSlabPolygonContext, slabPolygonContextChanges, slabPolygonContextForLevel, } from '@pascal-app/core';
+function sameReferences(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+export function createSlabDependencyTracker(initialNodes) {
+    let previous = new Map();
+    const nodeInputs = new WeakMap();
+    const sign = (node) => {
+        let value = nodeInputs.get(node);
+        if (value !== undefined)
+            return value;
+        value = JSON.stringify(node.type === 'wall'
+            ? [node.id, node.start, node.end, node.thickness, node.curveOffset]
+            : node.type === 'slab'
+                ? [
+                    node.id,
+                    node.polygon,
+                    node.elevation,
+                    node.thickness,
+                    node.recessed,
+                    node.fillToTerrain,
+                ]
+                : null);
+        nodeInputs.set(node, value);
+        return value;
+    };
+    const update = (nodes) => {
+        const levels = new Map();
+        for (const node of Object.values(nodes)) {
+            if (!node.parentId || node.type !== 'slab')
+                continue;
+            let context = levels.get(node.parentId);
+            if (!context) {
+                context = { slabs: [] };
+                levels.set(node.parentId, context);
+            }
+            context.slabs.push(node);
+        }
+        const current = new Map();
+        const dirty = [];
+        for (const [levelId, context] of levels) {
+            if (context.slabs.length === 0)
+                continue;
+            const level = nodes[levelId];
+            const polygonContext = slabPolygonContextForLevel(level ?? null, (id) => nodes[id], context.slabs);
+            const building = level?.parentId ? nodes[level.parentId] : undefined;
+            const cached = previous.get(levelId);
+            const references = { level, building, slabs: context.slabs, context: polygonContext };
+            if (cached &&
+                cached.references.level === level &&
+                cached.references.building === building &&
+                sameReferences(cached.references.slabs, context.slabs) &&
+                sameReferences(cached.references.context.walls, polygonContext.walls) &&
+                sameReferences(cached.references.context.siblingSlabs, polygonContext.siblingSlabs)) {
+                current.set(levelId, cached);
+                continue;
+            }
+            const transform = building?.type === 'building' ? [building.id, building.position, building.rotation] : null;
+            const transformSignature = JSON.stringify(transform);
+            const sameValues = (left, right) => left.length === right.length &&
+                left.every((node, index) => node === right[index] || sign(node) === sign(right[index]));
+            if (cached &&
+                cached.transform === transformSignature &&
+                sameValues(cached.references.context.walls, polygonContext.walls) &&
+                sameValues(cached.references.slabs, context.slabs) &&
+                sameValues(cached.references.context.siblingSlabs, polygonContext.siblingSlabs)) {
+                current.set(levelId, { ...cached, references });
+                continue;
+            }
+            const slabs = new Map();
+            const prepared = prepareSlabPolygonContext(polygonContext, cached?.prepared);
+            const affected = cached ? slabPolygonContextChanges(cached.prepared, prepared) : () => true;
+            for (const slab of context.slabs) {
+                const previousSlab = cached?.slabs.get(slab.id);
+                if (previousSlab &&
+                    (previousSlab.node === slab || sign(previousSlab.node) === sign(slab)) &&
+                    (!slab.fillToTerrain || slab.recessed || cached?.transform === transformSignature) &&
+                    !affected(slab)) {
+                    slabs.set(slab.id, previousSlab);
+                    continue;
+                }
+                const local = scopeSlabPolygonContext(slab, prepared);
+                const polygon = getRenderableSlabPolygon(slab, local);
+                // Compare the derived result: remote walls and seams can change the
+                // level context without changing this slab's geometry.
+                const signature = JSON.stringify([
+                    polygon,
+                    slab.elevation,
+                    slab.thickness,
+                    slab.recessed,
+                    slab.fillToTerrain && !slab.recessed ? transform : null,
+                ]);
+                slabs.set(slab.id, { node: slab, signature });
+                if (previousSlab?.signature !== signature)
+                    dirty.push(slab.id);
+            }
+            current.set(levelId, { prepared, transform: transformSignature, slabs, references });
+        }
+        previous = current;
+        return dirty;
+    };
+    update(initialNodes);
+    return update;
+}

package/dist/slab/floorplan-affordances.d.ts

@@ -2,13 +2,13 @@ export declare const slabMoveVertexAffordance: import("@pascal-app/core").Floorp
     object: "node";
     parentId: string | null;
     visible: boolean;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     id: `slab_${string}`;
     type: "slab";
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "elevator" | "stair" | "manual";
+        source: "stair" | "elevator" | "manual";
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -50,13 +50,13 @@ export declare const slabAddVertexAffordance: import("@pascal-app/core").Floorpl
     object: "node";
     parentId: string | null;
     visible: boolean;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     id: `slab_${string}`;
     type: "slab";
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "elevator" | "stair" | "manual";
+        source: "stair" | "elevator" | "manual";
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -98,13 +98,13 @@ export declare const slabMoveEdgeAffordance: import("@pascal-app/core").Floorpla
     object: "node";
     parentId: string | null;
     visible: boolean;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     id: `slab_${string}`;
     type: "slab";
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "elevator" | "stair" | "manual";
+        source: "stair" | "elevator" | "manual";
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];
@@ -146,13 +146,13 @@ export declare const slabDeleteVertexAffordance: import("@pascal-app/core").Floo
     object: "node";
     parentId: string | null;
     visible: boolean;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     id: `slab_${string}`;
     type: "slab";
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
-        source: "elevator" | "stair" | "manual";
+        source: "stair" | "elevator" | "manual";
         stairId?: string | undefined;
         elevatorId?: string | undefined;
     }[];