@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/site/renderer.js

@@ -1,14 +1,16 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-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 { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { sightTriangle, streetCorners, terrainContours, terrainFieldOf, unionPolygons, useLiveNodeOverrides, useLiveTerrain, useRegistry, useScene, } from '@pascal-app/core';
+import { backdropGradient, deepSkyColor, getSceneTheme, horizonHazeColor, NodeRenderer, useImmersiveXRPresentation, useNodeEvents, useSceneAtmosphere, useSceneGroundReplacement, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef } from 'react';
-import { BufferAttribute, BufferGeometry, Path, Shape, ShapeGeometry } from 'three';
+import { BufferAttribute, BufferGeometry, DoubleSide, Path, Shape, ShapeGeometry, } from 'three';
 import { cameraPosition, color, mix, positionWorld, smoothstep, float as tslFloat, vec2, } from 'three/tsl';
 import { MeshLambertNodeMaterial } from 'three/webgpu';
+import { buildPatternedRibbon, PROPERTY_LINE_PATTERN, SETBACK_LINE_PATTERN, updateRibbonHeights, } from './line-ribbon';
 import { getRecessedSlabGroundHoles } from './recessed-slab-ground-holes';
+import { resolveFrontEdge, setbackEnvelope } from './setbacks';
 import { buildDrapedPolyline, terrainGridKey, updateDrapedHeights, } from './terrain-drape';
-import { HORIZON_PLANE_Y, terrainFootprint } from './terrain-geometry';
+import { HORIZON_PLANE_Y, terrainBlockBase } from './terrain-geometry';
 import { TerrainRenderer } from './terrain-renderer';
 const Y_OFFSET = 0.01;
 // The horizon disc is presentation-only — clicks must fall through to the
@@ -41,13 +43,15 @@ const createBoundaryLineGeometry = (points, field) => {
     geometry.setAttribute('uv', new BufferAttribute(uvs, 2));
     return { geometry, ring };
 };
-/**
- * Re-upload a draped ring's positions after an in-place height rewrite.
- *
- * No `addUpdateRange`: a dab can move any subset of the ring's vertices (the brush
- * is a disc, the ring is a loop, and the two intersect in up to four arcs), so a
- * range would either be the whole buffer or a list. The whole buffer is a few KB.
- */
+function redrapeRibbons(r, field) {
+    if (!r)
+        return;
+    updateRibbonHeights(r.property, field, Y_OFFSET);
+    if (r.envelope)
+        updateRibbonHeights(r.envelope, field, Y_OFFSET + 0.01);
+    for (const g of r.triangles)
+        updateRibbonHeights(g, field, Y_OFFSET + 0.012);
+}
 function markPositionsDirty(geometry) {
     const attribute = geometry.getAttribute('position');
     attribute.needsUpdate = true;
@@ -75,6 +79,7 @@ function addSlabHoles(shape, slabPolygons, originX = 0, originZ = 0) {
 }
 export const SiteRenderer = ({ node }) => {
     const ref = useRef(null);
+    const immersiveXR = useImmersiveXRPresentation();
     const atmosphere = useSceneAtmosphere();
     const groundReplaced = useSceneGroundReplacement();
     useRegistry(node.id, 'site', ref);
@@ -201,10 +206,11 @@ export const SiteRenderer = ({ node }) => {
         addSlabHoles(shape, slabPolygons);
         return shape;
     }, [polygonPoints, slabPolygons]);
-    // The terrain footprint is punched out alongside the recessed slabs, and for the
-    // same reason: the disc must not cap ground that is modelled below it.
-    //
-    // 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.
+    // With terrain the lot is a block — its ground cut to the property line, its
+    // skirt dropping to one flat base — and the disc lies just under that base, so
+    // nothing of it caps the lot and nothing of the block stands proud of it from
+    // the far side. The recessed slabs are still punched: a basement can go deeper.
+    const horizonY = useMemo(() => (terrainGrid ? terrainBlockBase(terrainGrid) - 0.02 : HORIZON_PLANE_Y), [terrainGrid]);
     const horizonGeometry = useMemo(() => {
         if (!fadeBounds || groundReplaced)
             return null;
@@ -217,10 +223,9 @@ export const SiteRenderer = ({ node }) => {
             shape.lineTo(Math.cos(angle) * radius, Math.sin(angle) * radius);
         }
         shape.closePath();
-        const holes = terrainGrid ? [...slabPolygons, terrainFootprint(terrainGrid)] : slabPolygons;
-        addSlabHoles(shape, holes, fadeBounds.cx, fadeBounds.cz);
+        addSlabHoles(shape, slabPolygons, fadeBounds.cx, fadeBounds.cz);
         return new ShapeGeometry(shape);
-    }, [fadeBounds, slabPolygons, terrainKey, groundReplaced]);
+    }, [fadeBounds, slabPolygons, groundReplaced]);
     useEffect(() => () => horizonGeometry?.dispose(), [horizonGeometry]);
     useEffect(() => () => horizonMaterial?.dispose(), [horizonMaterial]);
     // Boundary line geometry, subdivided against the terrain grid when there is one.
@@ -242,6 +247,70 @@ export const SiteRenderer = ({ node }) => {
     }, [polygonPoints, terrainKey, node.id]);
     useEffect(() => () => boundary?.geometry.dispose(), [boundary]);
     const lineGeometry = boundary?.geometry ?? null;
+    // A site with drafted setbacks draws the PROPERTY LINE as the standard line —
+    // dark, thick, a long dash and two dots — and the SETBACK lines in black
+    // dashes, both ribbons lying on the draped ground (line-ribbon.ts). Any other
+    // site keeps the plain amber boundary. Keyed on the same grid as the
+    // boundary; a dab mid-stroke moves the thin ring only, the ribbons follow
+    // on the commit.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: keyed on the grid, not the field — see above.
+    const ribbons = useMemo(() => {
+        const setbacks = node.setbacks;
+        if (!setbacks || !boundary || !polygonPoints || polygonPoints.length < 3)
+            return null;
+        const field = useLiveTerrain.getState().fieldOf(node.id) ?? persistedField;
+        const property = buildPatternedRibbon(boundary.ring.positions, PROPERTY_LINE_PATTERN, 0.22);
+        let envelopeGeometry = null;
+        const triangleGeometries = [];
+        const points = polygonPoints.map(([x, z]) => [x ?? 0, z ?? 0]);
+        const front = resolveFrontEdge(points, node.frontEdge, node.northRotation ?? 0);
+        const streetEdges = node.streetEdges ?? [];
+        const sightTriangleM = typeof node.sightTriangleFt === 'number' && node.sightTriangleFt > 0
+            ? node.sightTriangleFt * 0.3048
+            : 0;
+        const envelope = setbackEnvelope(points, setbacks, front, { streetEdges, sightTriangleM });
+        if (envelope.length >= 3) {
+            const draped = buildDrapedPolyline({
+                points: envelope,
+                field,
+                lift: Y_OFFSET + 0.01,
+                closed: true,
+            });
+            envelopeGeometry = buildPatternedRibbon(draped.positions, SETBACK_LINE_PATTERN, 0.1);
+        }
+        // the corner sight triangles, dashed like the setbacks
+        if (sightTriangleM > 0) {
+            for (const [a, b] of streetCorners(points, [front, ...streetEdges])) {
+                const tri = sightTriangle(points, a, b, sightTriangleM);
+                if (!tri)
+                    continue;
+                const draped = buildDrapedPolyline({
+                    points: [tri.corner, tri.a, tri.b],
+                    field,
+                    lift: Y_OFFSET + 0.012,
+                    closed: true,
+                });
+                triangleGeometries.push(buildPatternedRibbon(draped.positions, SETBACK_LINE_PATTERN, 0.08));
+            }
+        }
+        return { property, envelope: envelopeGeometry, triangles: triangleGeometries };
+    }, [
+        boundary,
+        polygonPoints,
+        node.setbacks,
+        node.frontEdge,
+        node.streetEdges,
+        node.sightTriangleFt,
+        node.northRotation,
+        terrainKey,
+        node.id,
+    ]);
+    useEffect(() => () => {
+        ribbons?.property.dispose();
+        ribbons?.envelope?.dispose();
+        for (const g of ribbons?.triangles ?? [])
+            g.dispose();
+    }, [ribbons]);
     // Per-dab height rewrite, imperative for the same reason `TerrainRenderer`'s
     // upload is: a stroke pushes dozens of patches a second, and routing each through
     // a React render would rebuild the ring's buffers at pointer rate. The XZ of every
@@ -251,6 +320,8 @@ export const SiteRenderer = ({ node }) => {
     // polygon edit without resubscribing.
     const boundaryRef = useRef(null);
     boundaryRef.current = boundary;
+    const ribbonsRef = useRef(null);
+    ribbonsRef.current = ribbons;
     useEffect(() => {
         let lastPatch = useLiveTerrain.getState().strokeOf(node.id)?.lastPatch ?? null;
         return useLiveTerrain.subscribe((state) => {
@@ -267,6 +338,7 @@ export const SiteRenderer = ({ node }) => {
                     const field = terrainFieldOf({ id: node.id, terrain: node.terrain });
                     updateDrapedHeights(current.ring, field, Y_OFFSET);
                     markPositionsDirty(current.geometry);
+                    redrapeRibbons(ribbonsRef.current, field);
                 }
                 return;
             }
@@ -275,8 +347,68 @@ export const SiteRenderer = ({ node }) => {
             lastPatch = stroke.lastPatch;
             updateDrapedHeights(current.ring, stroke.field, Y_OFFSET);
             markPositionsDirty(current.geometry);
+            // the property and setback ribbons follow the same dab
+            redrapeRibbons(ribbonsRef.current, stroke.field);
         });
     }, [node.id, node.terrain]);
+    // The CONTOUR LINES on the ground (toggleable in 3D, drawn as faint,
+    // translucent near-black lines): the site's surveyed lines (the dossier's 3DEP set) at the
+    // site-plan interval, else the heightfield's own contours; each draped
+    // on the ground and merged into one line-segments buffer. Rebuilt on the
+    // terrain COMMIT (the persisted field), not per dab.
+    const contourGeometry = useMemo(() => {
+        if (!node.contours3d)
+            return null;
+        const intervalIn = node.contourIntervalIn ?? 12;
+        if (!(intervalIn > 0))
+            return null;
+        const field = persistedField;
+        const lot = (polygonPoints ?? []);
+        const stepFt = intervalIn / 12;
+        const surveyed = node.terrainContours;
+        const multiple = (a, b) => Math.abs(a / b - Math.round(a / b)) < 1e-9;
+        let lines = [];
+        if (surveyed && surveyed.lines.length > 0 && multiple(stepFt, surveyed.intervalFt)) {
+            lines = surveyed.lines.filter((l) => multiple(l.elevationFt, stepFt)).map((l) => l.points);
+        }
+        else if (field) {
+            lines = terrainContours(field, intervalIn * 0.0254, lot).map((c) => c.points);
+        }
+        const chunks = [];
+        let total = 0;
+        for (const points of lines) {
+            if (points.length < 2)
+                continue;
+            const draped = buildDrapedPolyline({ points, field, lift: Y_OFFSET + 0.005, closed: false });
+            const n = draped.positions.length / 3;
+            if (n < 2)
+                continue;
+            const seg = new Float32Array((n - 1) * 6);
+            for (let i = 0; i < n - 1; i++) {
+                seg[i * 6] = draped.positions[i * 3] ?? 0;
+                seg[i * 6 + 1] = draped.positions[i * 3 + 1] ?? 0;
+                seg[i * 6 + 2] = draped.positions[i * 3 + 2] ?? 0;
+                seg[i * 6 + 3] = draped.positions[i * 3 + 3] ?? 0;
+                seg[i * 6 + 4] = draped.positions[i * 3 + 4] ?? 0;
+                seg[i * 6 + 5] = draped.positions[i * 3 + 5] ?? 0;
+            }
+            chunks.push(seg);
+            total += seg.length;
+        }
+        if (total === 0)
+            return null;
+        const merged = new Float32Array(total);
+        let at = 0;
+        for (const c of chunks) {
+            merged.set(c, at);
+            at += c.length;
+        }
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new BufferAttribute(merged, 3));
+        geometry.computeBoundingSphere();
+        return geometry;
+    }, [node.contours3d, node.contourIntervalIn, node.terrainContours, persistedField, polygonPoints]);
+    useEffect(() => () => contourGeometry?.dispose(), [contourGeometry]);
     const groundGeometry = useMemo(() => {
         if (!groundShape)
             return null;
@@ -290,9 +422,15 @@ export const SiteRenderer = ({ node }) => {
     // inside TerrainRenderer so a stroke that starts on a site with no persisted
     // terrain still mounts the mesh.
     const showTerrain = terrainGrid !== null;
+    // The Site is the one kind whose `visible` flag stops at itself: hiding it
+    // drops the parcel's own presentation — ground fill, sculpted ground, lot
+    // line — while everything standing on the site keeps its own flag (the
+    // exporter and the 2D plan draw the same line). The horizon disc is a world
+    // backdrop rather than part of the parcel, so it stays either way.
+    const showSiteSurfaces = node.visible !== false;
     if (!(node && lineGeometry)) {
         return null;
     }
-    return (_jsxs("group", { ref: ref, ...handlers, children: [(node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))), showTerrain && _jsx(TerrainRenderer, { material: groundMaterial, site: node }), groundGeometry && !showTerrain && (_jsx("mesh", { geometry: groundGeometry, material: groundMaterial, position: [0, -0.05, 0], receiveShadow: true, rotation: [-Math.PI / 2, 0, 0] })), horizonGeometry && horizonMaterial && fadeBounds && (_jsx("mesh", { geometry: horizonGeometry, material: horizonMaterial, position: [fadeBounds.cx, HORIZON_PLANE_Y, fadeBounds.cz], raycast: noopRaycast, receiveShadow: true, rotation: [-Math.PI / 2, 0, 0], userData: { pascalExport: 'strip' } })), _jsx("line", { frustumCulled: false, geometry: lineGeometry, renderOrder: 9, children: _jsx("lineBasicMaterial", { color: "#f59e0b", linewidth: 2, opacity: 0.6, transparent: true }) })] }));
+    return (_jsxs("group", { ref: ref, ...handlers, children: [(node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))), showSiteSurfaces && showTerrain && (_jsx(TerrainRenderer, { holes: slabPolygons, material: groundMaterial, polygon: polygonPoints, site: node })), showSiteSurfaces && groundGeometry && !showTerrain && (_jsx("mesh", { geometry: groundGeometry, material: groundMaterial, position: [0, -0.05, 0], receiveShadow: true, rotation: [-Math.PI / 2, 0, 0] })), !immersiveXR && horizonGeometry && horizonMaterial && fadeBounds && (_jsx("mesh", { geometry: horizonGeometry, material: horizonMaterial, position: [fadeBounds.cx, horizonY, fadeBounds.cz], raycast: noopRaycast, receiveShadow: true, rotation: [-Math.PI / 2, 0, 0], userData: { pascalExport: 'strip' } })), showSiteSurfaces && ribbons && (_jsxs(_Fragment, { children: [_jsx("mesh", { frustumCulled: false, geometry: ribbons.property, raycast: noopRaycast, renderOrder: 9, children: _jsx("meshBasicMaterial", { color: "#1c1917", depthWrite: false, side: DoubleSide, toneMapped: false }) }), ribbons.envelope && (_jsx("mesh", { frustumCulled: false, geometry: ribbons.envelope, raycast: noopRaycast, renderOrder: 9, children: _jsx("meshBasicMaterial", { color: "#000000", depthWrite: false, opacity: 0.85, side: DoubleSide, toneMapped: false, transparent: true }) })), ribbons.triangles.map((g, i) => (_jsx("mesh", { frustumCulled: false, geometry: g, raycast: noopRaycast, renderOrder: 9, children: _jsx("meshBasicMaterial", { color: "#000000", depthWrite: false, opacity: 0.85, side: DoubleSide, toneMapped: false, transparent: true }) }, i))), _jsx("line", { frustumCulled: false, geometry: lineGeometry, renderOrder: 8, children: _jsx("lineBasicMaterial", { color: "#1c1917", opacity: 0.5, transparent: true }) })] })), showSiteSurfaces && !ribbons && (_jsx("line", { frustumCulled: false, geometry: lineGeometry, renderOrder: 9, children: _jsx("lineBasicMaterial", { color: "#f59e0b", linewidth: 2, opacity: 0.6, transparent: true }) })), showSiteSurfaces && contourGeometry && (_jsx("lineSegments", { frustumCulled: false, geometry: contourGeometry, raycast: noopRaycast, renderOrder: 8, children: _jsx("lineBasicMaterial", { color: "#000000", depthWrite: false, opacity: 0.22, toneMapped: false, transparent: true }) }))] }));
 };
 export default SiteRenderer;

package/dist/site/setbacks.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The setback envelope in the 3D site — the same rules the site plan draws
+ * (packages/editor/src/lib/floorplan/site-plan/geometry.ts: front edge,
+ * edge roles, per-role setbacks, offset-line intersections), ported here
+ * because the nodes package cannot import the editor. Pure. When the site
+ * has setbacks, the 3D view draws them black and dashed.
+ */
+export type Pt = readonly [number, number];
+export type EdgeRole = 'front' | 'rear' | 'left' | 'right' | 'street';
+export type SetbackInputs = {
+    front: number;
+    side: number;
+    rear: number;
+    left?: number;
+    right?: number;
+    /** A corner lot's second street side; absent = the front setback. */
+    streetSide?: number;
+};
+export declare function polygonArea(points: readonly Pt[]): number;
+export declare function isCounterClockwise(points: readonly Pt[]): boolean;
+/** Unit normal of edge i pointing OUT of the polygon (away from its centroid). */
+export declare function outwardNormal(points: readonly Pt[], i: number): Pt;
+/** The most north-facing edge (plan up = −z = north, turned by `northRotation`). */
+export declare function mostNorthFacingEdge(points: readonly Pt[], northRotation?: number): number;
+export declare function resolveFrontEdge(points: readonly Pt[], frontEdge: number | undefined, northRotation?: number): number;
+export declare function classifyEdges(points: readonly Pt[], frontIndex: number, streetEdges?: readonly number[]): EdgeRole[];
+export declare function setbackForRole(setbacks: SetbackInputs, role: EdgeRole): number;
+/** The buildable envelope: every edge pushed inward by its role's setback (see the editor's copy for the rules). */
+export declare function setbackEnvelope(points: readonly Pt[], setbacks: SetbackInputs, frontIndex: number, options?: {
+    streetEdges?: readonly number[];
+    sightTriangleM?: number;
+}): Pt[];
+//# sourceMappingURL=setbacks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setbacks.d.ts","sourceRoot":"","sources":["../../src/site/setbacks.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AACH,MAAM,MAAM,EAAE,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC1C,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAA;AACrE,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAID,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,GAAG,MAAM,CAQzD;AAYD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,GAAG,OAAO,CAEjE;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAwBlE;AAED,oFAAoF;AACpF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,aAAa,SAAI,GAAG,MAAM,CAcpF;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EAAE,EAAE,EACrB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,aAAa,SAAI,GAChB,MAAM,CASR;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,EAAE,EAAE,EACrB,UAAU,EAAE,MAAM,EAClB,WAAW,GAAE,SAAS,MAAM,EAAO,GAClC,QAAQ,EAAE,CAmDZ;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAa9E;AAED,oHAAoH;AACpH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,EAAE,EAAE,EACrB,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAO,GACzE,EAAE,EAAE,CAwDN"}

package/dist/site/setbacks.js

@@ -0,0 +1,204 @@
+import { arcRuns, insetPolygon, sightTriangle, streetCorners } from '@pascal-app/core';
+const EPS = 1e-9;
+export function polygonArea(points) {
+    let a = 0;
+    for (let i = 0; i < points.length; i++) {
+        const p = points[i];
+        const q = points[(i + 1) % points.length];
+        a += p[0] * q[1] - q[0] * p[1];
+    }
+    return Math.abs(a) / 2;
+}
+function signedArea(points) {
+    let a = 0;
+    for (let i = 0; i < points.length; i++) {
+        const p = points[i];
+        const q = points[(i + 1) % points.length];
+        a += p[0] * q[1] - q[0] * p[1];
+    }
+    return a / 2;
+}
+export function isCounterClockwise(points) {
+    return signedArea(points) > 0;
+}
+/** Unit normal of edge i pointing OUT of the polygon (away from its centroid). */
+export function outwardNormal(points, i) {
+    const n = points.length;
+    const p = points[i];
+    const q = points[(i + 1) % n];
+    const dx = q[0] - p[0];
+    const dy = q[1] - p[1];
+    const len = Math.hypot(dx, dy) || 1;
+    let nx = -dy / len;
+    let ny = dx / len;
+    let cx = 0;
+    let cy = 0;
+    for (const pt of points) {
+        cx += pt[0];
+        cy += pt[1];
+    }
+    cx /= n;
+    cy /= n;
+    const mx = (p[0] + q[0]) / 2;
+    const my = (p[1] + q[1]) / 2;
+    if ((mx - cx) * nx + (my - cy) * ny < 0) {
+        nx = -nx;
+        ny = -ny;
+    }
+    return [nx, ny];
+}
+/** The most north-facing edge (plan up = −z = north, turned by `northRotation`). */
+export function mostNorthFacingEdge(points, northRotation = 0) {
+    let best = 0;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < points.length; i++) {
+        const [nx, ny] = outwardNormal(points, i);
+        // heading of the outward normal, degrees clockwise from north
+        const heading = (((Math.atan2(nx, -ny) - northRotation) * 180) / Math.PI + 360) % 360;
+        const off = Math.min(heading, 360 - heading);
+        if (off < bestScore) {
+            bestScore = off;
+            best = i;
+        }
+    }
+    return best;
+}
+export function resolveFrontEdge(points, frontEdge, northRotation = 0) {
+    if (typeof frontEdge === 'number' &&
+        Number.isInteger(frontEdge) &&
+        frontEdge >= 0 &&
+        frontEdge < points.length)
+        return frontEdge;
+    return mostNorthFacingEdge(points, northRotation);
+}
+export function classifyEdges(points, frontIndex, streetEdges = []) {
+    const n = points.length;
+    const roles = new Array(n).fill('left');
+    if (n === 0)
+        return roles;
+    const front = ((frontIndex % n) + n) % n;
+    const fn = outwardNormal(points, front);
+    // a corner lot's other street edges (the parcel fabric's frontage) are
+    // 'street' — they take the street-side setback, never a side yard, and
+    // the rear is never one of them
+    const street = new Set(streetEdges.map((i) => ((i % n) + n) % n));
+    street.delete(front);
+    let rear = -1;
+    let rearDot = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < n; i++) {
+        if (i === front || street.has(i))
+            continue;
+        const ni = outwardNormal(points, i);
+        const dot = fn[0] * ni[0] + fn[1] * ni[1];
+        if (dot < rearDot) {
+            rearDot = dot;
+            rear = i;
+        }
+    }
+    const fp = points[front];
+    const fq = points[(front + 1) % n];
+    const dx = fq[0] - fp[0];
+    const dy = fq[1] - fp[1];
+    const len = Math.hypot(dx, dy) || 1;
+    const ux = dx / len;
+    const uy = dy / len;
+    const fmx = (fp[0] + fq[0]) / 2;
+    const fmy = (fp[1] + fq[1]) / 2;
+    for (let i = 0; i < n; i++) {
+        if (i === front) {
+            roles[i] = 'front';
+            continue;
+        }
+        if (street.has(i)) {
+            roles[i] = 'street';
+            continue;
+        }
+        if (i === rear) {
+            roles[i] = 'rear';
+            continue;
+        }
+        const p = points[i];
+        const q = points[(i + 1) % n];
+        const mx = (p[0] + q[0]) / 2 - fmx;
+        const my = (p[1] + q[1]) / 2 - fmy;
+        roles[i] = mx * ux + my * uy < 0 ? 'left' : 'right';
+    }
+    return roles;
+}
+export function setbackForRole(setbacks, role) {
+    switch (role) {
+        case 'front':
+            return setbacks.front;
+        case 'street':
+            return setbacks.streetSide ?? setbacks.front;
+        case 'rear':
+            return setbacks.rear;
+        case 'left':
+            return setbacks.left ?? setbacks.side;
+        case 'right':
+            return setbacks.right ?? setbacks.side;
+    }
+}
+/** The buildable envelope: every edge pushed inward by its role's setback (see the editor's copy for the rules). */
+export function setbackEnvelope(points, setbacks, frontIndex, options = {}) {
+    const n = points.length;
+    if (n < 3)
+        return [];
+    const streetEdges = options.streetEdges ?? [];
+    const roles = classifyEdges(points, frontIndex, streetEdges);
+    // A radius drawn as a run of short edges takes ONE role. A curb return
+    // is street frontage: a run carrying, or touching, a front / street edge
+    // is front / street all along (otherwise the last sliver of the return
+    // became a side yard, and the envelope jutted out toward the corner); a
+    // run carrying the rear is rear; else each sliver keeps its own side.
+    const runs = arcRuns(points);
+    const runRole = new Map();
+    const streetLike = (r) => r === 'front' || r === 'street';
+    for (let i = 0; i < n; i++) {
+        const r = roles[i];
+        const g = runs[i];
+        const have = runRole.get(g);
+        if (streetLike(r) || (r === 'rear' && !(have && streetLike(have))))
+            runRole.set(g, r);
+        else if (!have)
+            runRole.set(g, r);
+    }
+    for (let i = 0; i < n; i++) {
+        const g = runs[i];
+        const have = runRole.get(g);
+        if (streetLike(have))
+            continue;
+        const before = roles[(i - 1 + n) % n];
+        const after = roles[(i + 1) % n];
+        const members = runs.filter((x) => x === g).length;
+        if (members > 1) {
+            if (runs[(i - 1 + n) % n] !== g && streetLike(before))
+                runRole.set(g, before);
+            else if (runs[(i + 1) % n] !== g && streetLike(after))
+                runRole.set(g, after);
+        }
+    }
+    const distances = [];
+    for (let i = 0; i < n; i++) {
+        const role = runRole.get(runs[i]) ?? roles[i];
+        const d = setbackForRole(setbacks, role === 'left' || role === 'right' ? roles[i] : role);
+        if (!Number.isFinite(d) || d < 0)
+            return [];
+        distances.push(d);
+    }
+    // the corner sight triangles keep the envelope out of the clear-vision
+    // zone at each street intersection (the hypotenuse is a half-plane)
+    const keepOut = [];
+    if (options.sightTriangleM && options.sightTriangleM > 0) {
+        for (const [a, b] of streetCorners(points, [frontIndex, ...streetEdges])) {
+            const tri = sightTriangle(points, a, b, options.sightTriangleM);
+            if (tri)
+                keepOut.push({ a: tri.a, b: tri.b, inside: tri.corner });
+        }
+    }
+    // the true inward offset (core setback-envelope.ts): straight where the
+    // lot is straight, concentric round a radius, clipped where the offsets
+    // cross — the industry-standard setback for pie shapes, radius corners
+    // and odd lots
+    return insetPolygon(points, distances, { keepOut });
+}

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

@@ -32,6 +32,14 @@ import { type HeightPatch, type TerrainField } from '@pascal-app/core';
  * one. Two readers, one number.
  */
 export declare const HORIZON_PLANE_Y = -0.07;
+/**
+ * How far the skirt's base hangs below the lowest thing it must close over.
+ *
+ * Only the top edge is visually load-bearing; the base just has to be out of sight
+ * 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.
+ */
+export declare const SKIRT_DROP = 1;
 /** One vertex per sample, row-major — index `r * cols + c` matches the field. */
 export type TerrainMeshBuffers = {
     /** xyz per sample, length `cols * rows * 3`. */
@@ -68,6 +76,11 @@ export type TerrainSkirtBuffers = {
     positions: Float32Array;
     normals: Float32Array;
     indices: Uint32Array;
+    /**
+     * When the skirt follows the lot's property line (`skirtRing`): its x, z pairs,
+     * counter-clockwise. Absent, the skirt runs round the field's own rectangle.
+     */
+    ring?: Float32Array;
 };
 /**
  * The field's own footprint, as a polygon to punch out of the horizon disc.
@@ -89,7 +102,21 @@ export type TerrainSkirtBuffers = {
  * decides whether a pit is visible, and that is a property to assert, not to eyeball.
  */
 export declare function terrainFootprint(field: TerrainField): Array<[number, number]>;
-export declare function buildTerrainSkirt(field: TerrainField): TerrainSkirtBuffers;
+/**
+ * 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 declare function terrainBlockBase(field: TerrainField): number;
+/**
+ * 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 declare function skirtRing(field: TerrainField, polygon: ReadonlyArray<readonly [number, number]>): Float32Array;
+export declare function buildTerrainSkirt(field: TerrainField, ring?: Float32Array | null): TerrainSkirtBuffers;
 /**
  * Rewrite the whole skirt in place.
  *

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,CAoBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,WAAW,GACjB,IAAI,CA8BN"}
+{"version":3,"file":"terrain-geometry.d.ts","sourceRoot":"","sources":["../../src/site/terrain-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAIhB,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAAQ,CAAA;AAEpC;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,IAAI,CAAA;AAE3B,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;IACpB;;;OAGG;IACH,IAAI,CAAC,EAAE,YAAY,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAY7E;AAwBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAO5D;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAChD,YAAY,CAmBd;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,YAAY,EACnB,IAAI,CAAC,EAAE,YAAY,GAAG,IAAI,GACzB,mBAAmB,CAwBrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CA6B1F;AAgDD;;;;;;;;;;;;;;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"}