@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/site/terrain-geometry.js

@@ -1,4 +1,4 @@
-import { heightAtSample, normalAt } from '@pascal-app/core';
+import { heightAt, heightAtSample, normalAt, } from '@pascal-app/core';
 /**
  * Builds the terrain mesh buffers from a `TerrainField`.
  *
@@ -39,7 +39,7 @@ export const HORIZON_PLANE_Y = -0.07;
  * under the horizon disc. A metre reads as earth thickness from a grazing camera
  * without being tall enough to poke out of a neighbouring excavation.
  */
-const SKIRT_DROP = 1;
+export const SKIRT_DROP = 1;
 /** Vertex index of sample [c,r]. */
 function vertexIndex(field, col, row) {
     return row * field.cols + col;
@@ -148,13 +148,58 @@ function boundarySample(field, i) {
         return { col: 2 * lastCol + lastRow - i, row: lastRow };
     return { col: 0, row: 2 * (lastCol + lastRow) - i };
 }
-export function buildTerrainSkirt(field) {
-    const count = perimeterCount(field);
+/**
+ * The base of the lot as a block: one flat level under the field's lowest
+ * point (and under the horizon plane), so the skirt along the property line
+ * reads as earth whose thickness follows the slope, and the horizon disc can
+ * sit just beneath it without cutting into the lot anywhere.
+ */
+export function terrainBlockBase(field) {
+    let minH = 0;
+    for (let i = 0; i < field.heights.length; i++) {
+        const h = field.heights[i] ?? 0;
+        if (h < minH)
+            minH = h;
+    }
+    return Math.min(minH * field.step, HORIZON_PLANE_Y) - SKIRT_DROP;
+}
+/**
+ * The lot's property line as the skirt walks it: counter-clockwise in x, z (the
+ * field perimeter's own direction, so one winding and one normal formula serve
+ * both), a point at least every half grid cell so the top edge follows the
+ * ground between samples. Empty when the polygon is not a ring.
+ */
+export function skirtRing(field, polygon) {
+    const points = polygon.filter(([x, z]) => Number.isFinite(x) && Number.isFinite(z));
+    if (points.length < 3 || field.cols < 2 || field.rows < 2)
+        return new Float32Array(0);
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const [x0, z0] = points[i];
+        const [x1, z1] = points[(i + 1) % points.length];
+        area += x0 * z1 - x1 * z0;
+    }
+    const ordered = area > 0 ? points : [...points].reverse();
+    const step = field.spacing / 2;
+    const out = [];
+    for (let i = 0; i < ordered.length; i++) {
+        const [ax, az] = ordered[i];
+        const [bx, bz] = ordered[(i + 1) % ordered.length];
+        const n = Math.max(1, Math.ceil(Math.hypot(bx - ax, bz - az) / step));
+        for (let k = 0; k < n; k++)
+            out.push(ax + ((bx - ax) * k) / n, az + ((bz - az) * k) / n);
+    }
+    return Float32Array.from(out);
+}
+export function buildTerrainSkirt(field, ring) {
+    const onRing = !!ring && ring.length >= 6;
+    const count = onRing ? ring.length / 2 : perimeterCount(field);
     const vertices = count === 0 ? 0 : (count + 1) * 2;
     const buffers = {
         positions: new Float32Array(vertices * 3),
         normals: new Float32Array(vertices * 3),
         indices: new Uint32Array(count * 6),
+        ...(onRing ? { ring: ring } : {}),
     };
     for (let i = 0; i < count; i++) {
         const base = i * 6;
@@ -181,6 +226,10 @@ export function buildTerrainSkirt(field) {
  * complexity because it saves 400 KB a dab; here there is nothing to save.
  */
 export function updateTerrainSkirt(field, buffers) {
+    if (buffers.ring) {
+        updateRingSkirt(field, buffers, buffers.ring);
+        return;
+    }
     const count = perimeterCount(field);
     if (count === 0)
         return;
@@ -204,6 +253,31 @@ export function updateTerrainSkirt(field, buffers) {
         writeSkirtVertex(buffers, bottomIndex, x, Math.min(h, HORIZON_PLANE_Y) - SKIRT_DROP, z, nx, nz);
     }
 }
+/**
+ * The property-line skirt: its top on the rendered ground (`heightAt`, the
+ * surface's own triangles), its bottom on the block's flat base — never above
+ * the ground it closes, so nothing stands proud of the lot from any side.
+ */
+function updateRingSkirt(field, buffers, ring) {
+    const count = ring.length / 2;
+    if (count < 3)
+        return;
+    const base = terrainBlockBase(field);
+    for (let i = 0; i <= count; i++) {
+        const at = i % count;
+        const x = ring[at * 2] ?? 0;
+        const z = ring[at * 2 + 1] ?? 0;
+        const prev = (at - 1 + count) % count;
+        const next = (at + 1) % count;
+        const tx = (ring[next * 2] ?? 0) - (ring[prev * 2] ?? 0);
+        const tz = (ring[next * 2 + 1] ?? 0) - (ring[prev * 2 + 1] ?? 0);
+        const tLength = Math.hypot(tx, tz) || 1;
+        const nx = tz / tLength;
+        const nz = -tx / tLength;
+        writeSkirtVertex(buffers, i * 2, x, heightAt(field, x, z), z, nx, nz);
+        writeSkirtVertex(buffers, i * 2 + 1, x, base, z, nx, nz);
+    }
+}
 function writeSkirtVertex(buffers, index, x, y, z, nx, nz) {
     buffers.positions[index * 3] = x;
     buffers.positions[index * 3 + 1] = y;

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

@@ -0,0 +1,15 @@
+import { type Ring } from '@pascal-app/core';
+import { BufferGeometry } from 'three';
+import type { TerrainMeshBuffers } from './terrain-geometry';
+type Sample = {
+    indices: number[];
+    weights: number[];
+};
+export type TerrainHoleBoundary = {
+    geometry: BufferGeometry;
+    samples: Sample[];
+};
+export declare function cutTerrainHoles(buffers: TerrainMeshBuffers, holes: Ring[]): TerrainHoleBoundary | null;
+export declare function updateTerrainHoleBoundary(boundary: TerrainHoleBoundary, buffers: TerrainMeshBuffers): void;
+export {};
+//# sourceMappingURL=terrain-holes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-holes.d.ts","sourceRoot":"","sources":["../../src/site/terrain-holes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,IAAI,EAAS,MAAM,kBAAkB,CAAA;AAC/D,OAAO,EAAmB,cAAc,EAAyC,MAAM,OAAO,CAAA;AAC9F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAE5D,KAAK,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AACtD,MAAM,MAAM,mBAAmB,GAAG;IAAE,QAAQ,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAIjF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,IAAI,EAAE,GACZ,mBAAmB,GAAG,IAAI,CAkE5B;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,kBAAkB,GAC1B,IAAI,CAkBN"}

package/dist/site/terrain-holes.js

@@ -0,0 +1,74 @@
+import { difference, union } from '@pascal-app/core';
+import { BufferAttribute, BufferGeometry, DynamicDrawUsage, ShapeUtils, Vector2 } from 'three';
+// Keep the regular grid's vertex layout for partial brush uploads. Only triangles
+// crossing an excavation rim need additional vertices, interpolated on that grid.
+export function cutTerrainHoles(buffers, holes) {
+    if (!holes.length)
+        return null;
+    const cutouts = union(holes);
+    const bounds = cutouts.map(({ outer }) => ({
+        minX: Math.min(...outer.map(([x]) => x)),
+        maxX: Math.max(...outer.map(([x]) => x)),
+        minZ: Math.min(...outer.map(([, z]) => z)),
+        maxZ: Math.max(...outer.map(([, z]) => z)),
+    }));
+    const kept = [], indices = [], samples = [];
+    for (let i = 0; i < buffers.indices.length; i += 3) {
+        const source = Array.from(buffers.indices.subarray(i, i + 3));
+        const triangle = source.map((id) => [
+            buffers.positions[id * 3],
+            buffers.positions[id * 3 + 2],
+        ]);
+        const xs = triangle.map(([x]) => x), zs = triangle.map(([, z]) => z);
+        if (!bounds.some((box) => box.maxX > Math.min(...xs) &&
+            box.minX < Math.max(...xs) &&
+            box.maxZ > Math.min(...zs) &&
+            box.minZ < Math.max(...zs))) {
+            kept.push(...source);
+            continue;
+        }
+        const [a, b, c] = triangle;
+        const determinant = (b[1] - c[1]) * (a[0] - c[0]) + (c[0] - b[0]) * (a[1] - c[1]);
+        for (const polygon of difference(triangle, cutouts)) {
+            const contour = polygon.outer.map(([x, z]) => new Vector2(x, z));
+            const voids = polygon.holes.map((ring) => ring.map(([x, z]) => new Vector2(x, z)));
+            const offset = samples.length;
+            for (const { x, y: z } of [contour, ...voids].flat()) {
+                const wa = ((b[1] - c[1]) * (x - c[0]) + (c[0] - b[0]) * (z - c[1])) / determinant;
+                const wb = ((c[1] - a[1]) * (x - c[0]) + (a[0] - c[0]) * (z - c[1])) / determinant;
+                samples.push({ indices: source, weights: [wa, wb, 1 - wa - wb] });
+            }
+            for (const [a, b, c] of ShapeUtils.triangulateShape(contour, voids))
+                indices.push(offset + c, offset + b, offset + a);
+        }
+    }
+    buffers.indices = new Uint32Array(kept);
+    const geometry = new BufferGeometry();
+    for (const name of ['position', 'normal'])
+        geometry.setAttribute(name, new BufferAttribute(new Float32Array(samples.length * 3), 3).setUsage(DynamicDrawUsage));
+    const uv = new Float32Array(samples.length * 2);
+    for (let i = 0; i < samples.length; i++)
+        for (let axis = 0; axis < 2; axis++)
+            uv[i * 2 + axis] = samples[i].indices.reduce((sum, id, j) => sum + buffers.uvs[id * 2 + axis] * samples[i].weights[j], 0);
+    geometry.setAttribute('uv', new BufferAttribute(uv, 2));
+    geometry.setIndex(indices);
+    const boundary = { geometry, samples };
+    updateTerrainHoleBoundary(boundary, buffers);
+    return boundary;
+}
+export function updateTerrainHoleBoundary(boundary, buffers) {
+    for (const [name, source] of [
+        ['position', buffers.positions],
+        ['normal', buffers.normals],
+    ]) {
+        const attribute = boundary.geometry.getAttribute(name);
+        for (let i = 0; i < boundary.samples.length; i++) {
+            const sample = boundary.samples[i];
+            for (let axis = 0; axis < 3; axis++)
+                attribute.array[i * 3 + axis] = sample.indices.reduce((sum, id, j) => sum + source[id * 3 + axis] * sample.weights[j], 0);
+        }
+        attribute.needsUpdate = true;
+    }
+    boundary.geometry.normalizeNormals();
+    boundary.geometry.computeBoundingSphere();
+}

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

@@ -1,6 +1,7 @@
-import type { HeightPatch, TerrainField } from '@pascal-app/core';
+import type { HeightPatch, Ring, TerrainField } from '@pascal-app/core';
 import { BufferGeometry } from 'three';
 import { type TerrainMeshBuffers, type TerrainSkirtBuffers } from './terrain-geometry';
+import { type TerrainHoleBoundary } from './terrain-holes';
 /**
  * The Three.js side of the terrain heightfield: owns the `BufferGeometry` and the
  * dirty-rect upload.
@@ -20,6 +21,7 @@ import { type TerrainMeshBuffers, type TerrainSkirtBuffers } from './terrain-geo
 /** A terrain geometry plus the CPU buffers backing it. */
 export type TerrainGeometry = {
     readonly geometry: BufferGeometry;
+    readonly holeBoundary: TerrainHoleBoundary | null;
     readonly buffers: TerrainMeshBuffers;
     /** Expands during live edits; a committed-field rebuild tightens it again. */
     readonly heightBounds: {
@@ -32,7 +34,12 @@ export type TerrainGeometry = {
         readonly buffers: TerrainSkirtBuffers;
     };
 };
-export declare function createTerrainGeometry(field: TerrainField): TerrainGeometry;
+/**
+ * `ring` (from `skirtRing`) runs the skirt along the lot's property line instead
+ * of the field's rectangle: the surface is cut to the lot by its material (see
+ * `lotMaskedMaterial`), and the skirt closes it as a block with a flat base.
+ */
+export declare function createTerrainGeometry(field: TerrainField, holes?: Ring[], ring?: Float32Array | null): TerrainGeometry;
 /**
  * Push one patch to the GPU, touching only the affected rows.
  *

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,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"}
+{"version":3,"file":"terrain-mesh.d.ts","sourceRoot":"","sources":["../../src/site/terrain-mesh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,EAAmB,cAAc,EAA4B,MAAM,OAAO,CAAA;AACjF,OAAO,EAML,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EAGzB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,iBAAiB,CAAA;AAExB;;;;;;;;;;;;;;;GAeG;AAEH,0DAA0D;AAC1D,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAA;IACjD,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;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,YAAY,EACnB,KAAK,GAAE,IAAI,EAAO,EAClB,IAAI,GAAE,YAAY,GAAG,IAAW,GAC/B,eAAe,CAyCjB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,WAAW,GACjB,IAAI,CA+CN;AAoFD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAElF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAIpE"}

package/dist/site/terrain-mesh.js

@@ -1,7 +1,14 @@
 import { BufferAttribute, BufferGeometry, DynamicDrawUsage, Sphere } from 'three';
-import { buildTerrainMesh, buildTerrainSkirt, HORIZON_PLANE_Y, patchUpdateRange, updateTerrainMesh, updateTerrainSkirt, } from './terrain-geometry';
-export function createTerrainGeometry(field) {
+import { buildTerrainMesh, buildTerrainSkirt, HORIZON_PLANE_Y, patchUpdateRange, SKIRT_DROP, updateTerrainMesh, updateTerrainSkirt, } from './terrain-geometry';
+import { cutTerrainHoles, updateTerrainHoleBoundary, } from './terrain-holes';
+/**
+ * `ring` (from `skirtRing`) runs the skirt along the lot's property line instead
+ * of the field's rectangle: the surface is cut to the lot by its material (see
+ * `lotMaskedMaterial`), and the skirt closes it as a block with a flat base.
+ */
+export function createTerrainGeometry(field, holes = [], ring = null) {
     const buffers = buildTerrainMesh(field);
+    const holeBoundary = cutTerrainHoles(buffers, holes);
     const geometry = new BufferGeometry();
     geometry.setAttribute('position', new BufferAttribute(buffers.positions, 3).setUsage(DynamicDrawUsage));
     geometry.setAttribute('normal', new BufferAttribute(buffers.normals, 3).setUsage(DynamicDrawUsage));
@@ -12,14 +19,17 @@ export function createTerrainGeometry(field) {
     // 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 skirtBuffers = buildTerrainSkirt(field, ring);
     const skirtGeometry = new BufferGeometry();
     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));
+    if (skirtBuffers.ring)
+        skirtGeometry.userData.ring = skirtBuffers.ring;
     setSkirtBounds(skirtGeometry, field, span);
     return {
         geometry,
+        holeBoundary,
         buffers,
         heightBounds: span,
         skirt: { geometry: skirtGeometry, buffers: skirtBuffers },
@@ -38,7 +48,10 @@ export function applyTerrainPatch(target, field, patch) {
     if (!range)
         return;
     updateTerrainMesh(field, target.buffers, patch);
-    if (patch.col0 <= 0 ||
+    if (target.holeBoundary)
+        updateTerrainHoleBoundary(target.holeBoundary, target.buffers);
+    if (target.skirt.buffers.ring ||
+        patch.col0 <= 0 ||
         patch.row0 <= 0 ||
         patch.col0 + patch.cols >= field.cols ||
         patch.row0 + patch.rows >= field.rows) {
@@ -111,12 +124,25 @@ function setTerrainBounds(geometry, field, { minY, maxY }) {
  * same reason the geometry does.
  */
 function setSkirtBounds(geometry, field, { minY, maxY }) {
-    const low = Math.min(minY, HORIZON_PLANE_Y) - 1;
+    const low = Math.min(minY, HORIZON_PLANE_Y) - SKIRT_DROP;
     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;
+    let minX = field.origin[0];
+    let minZ = field.origin[1];
+    let maxX = minX + (field.cols - 1) * field.spacing;
+    let maxZ = minZ + (field.rows - 1) * field.spacing;
+    const ring = geometry.userData.ring;
+    if (ring && ring.length >= 6) {
+        minX = maxX = ring[0] ?? 0;
+        minZ = maxZ = ring[1] ?? 0;
+        for (let i = 2; i < ring.length; i += 2) {
+            const x = ring[i] ?? 0;
+            const z = ring[i + 1] ?? 0;
+            minX = Math.min(minX, x);
+            maxX = Math.max(maxX, x);
+            minZ = Math.min(minZ, z);
+            maxZ = Math.max(maxZ, z);
+        }
+    }
     geometry.boundingSphere ??= new Sphere();
     const sphere = geometry.boundingSphere;
     sphere.center.set((minX + maxX) / 2, (low + high) / 2, (minZ + maxZ) / 2);
@@ -147,5 +173,6 @@ export function needsRebuild(target, field) {
 }
 export function disposeTerrainGeometry(target) {
     target.geometry.dispose();
+    target.holeBoundary?.geometry.dispose();
     target.skirt.geometry.dispose();
 }

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

@@ -1,4 +1,4 @@
-import { type SiteNode } from '@pascal-app/core';
+import { type Ring, type SiteNode } from '@pascal-app/core';
 import type { Material } from 'three';
 /**
  * Renders the site's sculpted ground.
@@ -19,10 +19,17 @@ import type { Material } from 'three';
  *   the editor layer, but moving actual scene geometry there would exclude it from
  *   the MRT depth/normal pass and break the screen-space ink against it.
  */
-export declare const TerrainRenderer: ({ material, site, }: {
+export declare const TerrainRenderer: ({ material, site, holes, polygon, }: {
     /** Owned by `SiteRenderer` so the ground material stays defined in one place. */
     material: Material;
     site: SiteNode;
+    holes: Ring[];
+    /**
+     * The lot's property line (live while it is being edited). With one, the
+     * ground is the lot alone — cut to the line, closed by a skirt down to a flat
+     * base — rather than the field's padded box.
+     */
+    polygon?: ReadonlyArray<readonly [number, number]> | null;
 }) => import("react").JSX.Element | null;
 export default TerrainRenderer;
 //# sourceMappingURL=terrain-renderer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"terrain-renderer.d.ts","sourceRoot":"","sources":["../../src/site/terrain-renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAkC,MAAM,kBAAkB,CAAA;AAEhF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AASrC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,GAAI,qBAG7B;IACD,iFAAiF;IACjF,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,QAAQ,CAAA;CACf,uCA6DA,CAAA;AAED,eAAe,eAAe,CAAA"}
+{"version":3,"file":"terrain-renderer.d.ts","sourceRoot":"","sources":["../../src/site/terrain-renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAkC,MAAM,kBAAkB,CAAA;AAE3F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAWrC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,GAAI,qCAK7B;IACD,iFAAiF;IACjF,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,IAAI,EAAE,CAAA;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAAA;CAC1D,uCAoFA,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/site/terrain-renderer.js

@@ -2,6 +2,8 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { terrainFieldOf, useLiveTerrain } from '@pascal-app/core';
 import { useEffect, useMemo, useRef } from 'react';
+import { lotMaskedMaterial } from './lot-mask';
+import { skirtRing } from './terrain-geometry';
 import { applyTerrainPatch, createTerrainGeometry, disposeTerrainGeometry, needsRebuild, } from './terrain-mesh';
 /**
  * Renders the site's sculpted ground.
@@ -22,7 +24,7 @@ import { applyTerrainPatch, createTerrainGeometry, disposeTerrainGeometry, needs
  *   the editor layer, but moving actual scene geometry there would exclude it from
  *   the MRT depth/normal pass and break the screen-space ink against it.
  */
-export const TerrainRenderer = ({ material, site, }) => {
+export const TerrainRenderer = ({ material, site, holes, polygon, }) => {
     const targetRef = useRef(null);
     // Persisted terrain only — the live stroke is applied imperatively below, so a
     // dab never triggers a React render.
@@ -31,8 +33,16 @@ export const TerrainRenderer = ({ material, site, }) => {
         const field = useLiveTerrain.getState().fieldOf(site.id) ?? persistedField;
         if (!field)
             return null;
-        return createTerrainGeometry(field);
-    }, [persistedField, site.id]);
+        const ring = polygon && polygon.length >= 3 ? skirtRing(field, polygon) : null;
+        return createTerrainGeometry(field, holes, ring && ring.length >= 6 ? ring : null);
+    }, [persistedField, site.id, holes, polygon]);
+    // The surface (and the cut edges round recessed slabs) stop at the property
+    // line; the skirt keeps the plain material — it *is* the line.
+    const surfaceMaterial = useMemo(() => (polygon && polygon.length >= 3 ? lotMaskedMaterial(material, polygon) : material), [material, polygon]);
+    useEffect(() => () => {
+        if (surfaceMaterial !== material)
+            surfaceMaterial.dispose();
+    }, [surfaceMaterial, material]);
     targetRef.current = target;
     useEffect(() => () => {
         if (target)
@@ -64,6 +74,6 @@ export const TerrainRenderer = ({ material, site, }) => {
     }, [site.id]);
     if (!target)
         return null;
-    return (_jsxs(_Fragment, { children: [_jsx("mesh", { castShadow: true, geometry: target.geometry, material: material, receiveShadow: true }), _jsx("mesh", { geometry: target.skirt.geometry, material: material, receiveShadow: true })] }));
+    return (_jsxs(_Fragment, { children: [_jsx("mesh", { castShadow: true, geometry: target.geometry, material: surfaceMaterial, receiveShadow: true }), target.holeBoundary && (_jsx("mesh", { castShadow: true, geometry: target.holeBoundary.geometry, material: surfaceMaterial, receiveShadow: true })), _jsx("mesh", { geometry: target.skirt.geometry, material: material, receiveShadow: true })] }));
 };
 export default TerrainRenderer;

package/dist/slab/boundary-editor.d.ts

@@ -3,7 +3,7 @@ import { type SlabNode } from '@pascal-app/core';
  * Phase 5 Stage D — slab boundary editor (registry-driven).
  *
  * Thin wrapper around the shared `PolygonEditor`. Activates when a
- * slab is selected in structure/select mode (not currently editing a
+ * slab is selected in select mode (not currently editing a
  * hole). The heavy lifting — vertex drag, edge slide, snap, history
  * bracketing — lives in `PolygonEditor` itself.
  *

package/dist/slab/boundary-editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boundary-editor.d.ts","sourceRoot":"","sources":["../../src/slab/boundary-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAkC,MAAM,kBAAkB,CAAA;AAehG;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;CAAE,CAqInE,CAAA;AAED,eAAe,kBAAkB,CAAA"}
+{"version":3,"file":"boundary-editor.d.ts","sourceRoot":"","sources":["../../src/slab/boundary-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAkC,MAAM,kBAAkB,CAAA;AAehG;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;CAAE,CAwInE,CAAA;AAED,eAAe,kBAAkB,CAAA"}

package/dist/slab/boundary-editor.js

@@ -8,7 +8,7 @@ import { useCallback, useEffect } from 'react';
  * Phase 5 Stage D — slab boundary editor (registry-driven).
  *
  * Thin wrapper around the shared `PolygonEditor`. Activates when a
- * slab is selected in structure/select mode (not currently editing a
+ * slab is selected in select mode (not currently editing a
  * hole). The heavy lifting — vertex drag, edge slide, snap, history
  * bracketing — lives in `PolygonEditor` itself.
  *
@@ -24,16 +24,18 @@ import { useCallback, useEffect } from 'react';
  */
 export const SlabBoundaryEditor = ({ slabId }) => {
     const slabNode = useScene((s) => s.nodes[slabId]);
-    const updateNode = useScene((s) => s.updateNode);
+    const detachDerivedNode = useScene((s) => s.detachDerivedNode);
     const markDirty = useScene((s) => s.markDirty);
     const setSelection = useViewer((s) => s.setSelection);
     const slab = slabNode?.type === 'slab' ? slabNode : null;
     const slabLevelId = slab ? resolveLevelId(slab, useScene.getState().nodes) : null;
     const handlePolygonChange = useCallback((newPolygon) => {
         clearSlabSnapFeedback();
-        updateNode(slabId, { polygon: newPolygon, autoFromWalls: false });
+        // Reshaping the boundary is the sanctioned conversion of a derived floor
+        // plate into an authored slab — the reconciler stops owning it here.
+        detachDerivedNode(slabId, { polygon: newPolygon });
         setSelection({ selectedIds: [slabId] });
-    }, [slabId, updateNode, setSelection]);
+    }, [slabId, detachDerivedNode, setSelection]);
     const handlePolygonPreview = useCallback((preview) => {
         if (preview) {
             useLiveNodeOverrides.getState().set(slabId, {
@@ -110,15 +112,13 @@ export const SlabBoundaryEditor = ({ slabId }) => {
     // Guarantee the override clears if the editor unmounts mid-drag
     // (selection change, mode switch) so the slab mesh doesn't get stuck
     // on a stale polygon.
-    useEffect(() => {
-        return () => {
-            clearSlabSnapFeedback();
-            useLiveNodeOverrides.getState().clear(slabId);
-            useScene.getState().markDirty(slabId);
-            useInteractionScope
-                .getState()
-                .endIf((s) => s.kind === 'reshaping' && s.reshape === 'boundary');
-        };
+    useEffect(() => () => {
+        clearSlabSnapFeedback();
+        useLiveNodeOverrides.getState().clear(slabId);
+        useScene.getState().markDirty(slabId);
+        useInteractionScope
+            .getState()
+            .endIf((s) => s.kind === 'reshaping' && s.reshape === 'boundary');
     }, [slabId]);
     if (!slab?.polygon || slab.polygon.length < 3)
         return null;

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;AA8BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAsNnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAyH1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,cAAc,EAMpB,MAAM,kBAAkB,CAAA;AA+BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAyNnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAyI1D,CAAA"}

package/dist/slab/definition.js

@@ -1,5 +1,6 @@
-import { MIN_SLAB_THICKNESS, markSlabChangeDependents, pointInPolygon2D, syncStairRises, } from '@pascal-app/core';
+import { liftedManualSlab, MIN_SLAB_THICKNESS, markSlabChangeDependents, pointInPolygon2D, slabSlots, syncStairRises, } from '@pascal-app/core';
 import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { surfaceBatchable } from '../shared/node-batch/batchable';
 import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
 import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts';
 import { applySlabBaseElevationChange, applySlabThicknessChange, applySlabTopChange, getSlabBaseElevation, slabElevationUpperBound, } from './elevation-limit';
@@ -11,7 +12,6 @@ import { slabPaint } from './paint';
 import { slabParametrics } from './parametrics';
 import { slabQuickMeasurement } from './quick-measurement';
 import { SlabNode } from './schema';
-import { slabSlots } from './slots';
 const HEIGHT_HANDLE_OFFSET = 0.22;
 const MIN_SLAB_ELEVATION = -1;
 function polygonVertexAverage(polygon) {
@@ -171,6 +171,11 @@ function slabBaseElevationHandle() {
     };
 }
 function slabHandles(node) {
+    // A footprint's floor (base plate) has one control, its height above the
+    // ground, drawn by the editor's footprint height handle; room plates are
+    // reached through their room. Only user-drawn slabs keep these handles.
+    if (node.plateRole)
+        return [];
     return node.recessed
         ? [slabRecessedDepthHandle()]
         : [slabThicknessHandle(), slabBaseElevationHandle()];
@@ -220,9 +225,20 @@ export const slabDefinition = {
         autoFromWalls: false,
     }),
     capabilities: {
+        batchable: surfaceBatchable,
         selectable: { hitVolume: 'bbox' },
         surfaces: {
-            top: { height: (n) => n.elevation },
+            top: {
+                height: (n) => n.elevation,
+                supportHeight: (node, x, z, context) => {
+                    const slab = node;
+                    if (slab.polygon.length < 3 ||
+                        !pointInPolygon2D([x, z], slab.polygon, { includeBoundary: true }) ||
+                        slab.holes.some((hole) => hole.length >= 3 && pointInPolygon2D([x, z], hole, { includeBoundary: false })))
+                        return null;
+                    return liftedManualSlab(context.nodes, slab).elevation;
+                },
+            },
         },
         duplicable: true,
         deletable: true,

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

@@ -1 +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"}
+{"version":3,"file":"dependency-tracker.d.ts","sourceRoot":"","sources":["../../src/slab/dependency-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAYf,MAAM,kBAAkB,CAAA;AAsBzB,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAwDxD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,SAAS,EAAE,CAoH7D"}