@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/shared/wall-attach-target.js

@@ -219,70 +219,10 @@ export function snapLocalXToNeighbors(args) {
     return bestDelta === null ? null : localX + bestDelta;
 }
 /**
- * Does a wall-hosted opening of `width × height` centred at `(clampedX,
- * clampedY)` (wall-local) overlap any OTHER child of `wallId` (door / window /
- * wall-mounted item)? AABB test in the wall's local face plane. `ignoreId`
- * excludes the moving node itself. Returns `true` (blocked) if the wall is
- * gone.
- *
- * Single source of truth for door + window placement collision — door-math and
- * window-math had byte-identical copies of this. Y conventions differ per kind
- * (items store bottom Y; doors/windows store centre Y), handled inline.
+ * Whether a wall-hosted opening would overlap another child of its wall. The rule lives in
+ * core, shared with every agent surface (`planWallOpening`); re-exported for the tools here.
  */
-export function hasWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height, ignoreId) {
-    const wallNode = nodes[wallId];
-    if (!wallNode)
-        return true;
-    const halfW = width / 2;
-    const halfH = height / 2;
-    const newBottom = clampedY - halfH;
-    const newTop = clampedY + halfH;
-    const newLeft = clampedX - halfW;
-    const newRight = clampedX + halfW;
-    for (const childId of Array.isArray(wallNode.children) ? wallNode.children : []) {
-        if (childId === ignoreId)
-            continue;
-        const child = nodes[childId];
-        if (!child || child.metadata.isTransient)
-            continue;
-        let childLeft;
-        let childRight;
-        let childBottom;
-        let childTop;
-        if (child.type === 'item') {
-            const item = child;
-            if (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side')
-                continue;
-            const [w, h] = getScaledDimensions(item);
-            childLeft = item.position[0] - w / 2;
-            childRight = item.position[0] + w / 2;
-            childBottom = item.position[1]; // items store bottom Y
-            childTop = item.position[1] + h;
-        }
-        else if (child.type === 'window') {
-            const win = child;
-            childLeft = win.position[0] - win.width / 2;
-            childRight = win.position[0] + win.width / 2;
-            childBottom = win.position[1] - win.height / 2; // windows store centre Y
-            childTop = win.position[1] + win.height / 2;
-        }
-        else if (child.type === 'door') {
-            const door = child;
-            childLeft = door.position[0] - door.width / 2;
-            childRight = door.position[0] + door.width / 2;
-            childBottom = door.position[1] - door.height / 2; // doors store centre Y
-            childTop = door.position[1] + door.height / 2;
-        }
-        else {
-            continue;
-        }
-        const xOverlap = newLeft < childRight && newRight > childLeft;
-        const yOverlap = newBottom < childTop && newTop > childBottom;
-        if (xOverlap && yOverlap)
-            return true;
-    }
-    return false;
-}
+export { hasWallChildOverlap } from '@pascal-app/core/building';
 /**
  * Resolve the placement state from the raw collision result and whether the
  * user is force-placing (held Alt). Force-place lifts the collision block, so the

package/dist/shared/wall-opening-ceiling.d.ts

@@ -1,4 +1,5 @@
-import { type AnyNode, type AnyNodeId, type WallNode } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId, type DoorNode } from '@pascal-app/core';
+import { resolveWallOpeningCeiling } from '@pascal-app/core/building';
 /**
  * Structural subset of `SceneApi` the opening-cap readers need — matches
  * both handle-descriptor callbacks (which receive the full SceneApi) and
@@ -8,23 +9,12 @@ export type WallCeilingSceneReader = {
     get: (id: AnyNodeId) => unknown;
     nodes: () => Readonly<Record<AnyNodeId, AnyNode>>;
 };
-/**
- * Available wall-local Y span for an opening hosted on `wall`: the wall's
- * resolved top (storey plane for plane-bound walls, stored height for
- * explicit ones) minus the wall's elected slab base. Wall-local Y = 0 sits
- * at the elected base (where the viewer positions the wall mesh), so this
- * is the ceiling an opening's top edge must stay under.
- *
- * Uses the same slab election as the viewer's WallSystem
- * (`spatialGridManager.getSlabSupportForWall`) so the cap agrees with the
- * rendered wall; headless callers with an empty spatial grid elect base 0
- * and fall back to the full storey height.
- */
-export declare function resolveWallOpeningCeiling(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>): number;
+/** The ceiling an opening's top edge must stay under: the shared rule in core. */
+export { resolveWallOpeningCeiling };
 /**
  * Height cap for a wall-hosted opening's resize handles. Infinity only when
  * the opening is unhosted (no wallId, or the wall is gone) — roof-hosted
  * openings clamp elsewhere.
  */
-export declare function readHostWallCeiling(wallId: string | null | undefined, scene: WallCeilingSceneReader): number;
+export declare function readHostWallCeiling(wallId: string | null | undefined, scene: WallCeilingSceneReader, opening?: Pick<DoorNode, 'position' | 'width' | 'height'>): number;
 //# sourceMappingURL=wall-opening-ceiling.d.ts.map

package/dist/shared/wall-opening-ceiling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-opening-ceiling.d.ts","sourceRoot":"","sources":["../../src/shared/wall-opening-ceiling.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAA;IAC/B,KAAK,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,sBAAsB,GAC5B,MAAM,CAKR"}
+{"version":3,"file":"wall-opening-ceiling.d.ts","sourceRoot":"","sources":["../../src/shared/wall-opening-ceiling.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AAErE;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAA;IAC/B,KAAK,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD,CAAA;AAED,kFAAkF;AAClF,OAAO,EAAE,yBAAyB,EAAE,CAAA;AAEpC;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,sBAAsB,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,GACxD,MAAM,CASR"}

package/dist/shared/wall-opening-ceiling.js

@@ -1,29 +1,21 @@
-import { getWallEffectiveHeightForNodes, } from '@pascal-app/core';
-/**
- * Available wall-local Y span for an opening hosted on `wall`: the wall's
- * resolved top (storey plane for plane-bound walls, stored height for
- * explicit ones) minus the wall's elected slab base. Wall-local Y = 0 sits
- * at the elected base (where the viewer positions the wall mesh), so this
- * is the ceiling an opening's top edge must stay under.
- *
- * Uses the same slab election as the viewer's WallSystem
- * (`spatialGridManager.getSlabSupportForWall`) so the cap agrees with the
- * rendered wall; headless callers with an empty spatial grid elect base 0
- * and fall back to the full storey height.
- */
-export function resolveWallOpeningCeiling(wall, nodes) {
-    return getWallEffectiveHeightForNodes(wall, nodes);
-}
+import { getOpeningFloorDatum, wallSupportForNodes, } from '@pascal-app/core';
+import { resolveWallOpeningCeiling } from '@pascal-app/core/building';
+/** The ceiling an opening's top edge must stay under: the shared rule in core. */
+export { resolveWallOpeningCeiling };
 /**
  * Height cap for a wall-hosted opening's resize handles. Infinity only when
  * the opening is unhosted (no wallId, or the wall is gone) — roof-hosted
  * openings clamp elsewhere.
  */
-export function readHostWallCeiling(wallId, scene) {
+export function readHostWallCeiling(wallId, scene, opening) {
     if (!wallId)
         return Number.POSITIVE_INFINITY;
     const wall = scene.get(wallId);
     if (!wall)
         return Number.POSITIVE_INFINITY;
-    return resolveWallOpeningCeiling(wall, scene.nodes());
+    const nodes = scene.nodes();
+    const lift = opening
+        ? getOpeningFloorDatum(wall, opening, nodes) - wallSupportForNodes(wall, nodes).elevation
+        : 0;
+    return resolveWallOpeningCeiling(wall, nodes) - lift;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AASpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA4HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAyJ5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAUpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA2HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAyJ5D,CAAA"}

package/dist/shelf/definition.js

@@ -1,3 +1,4 @@
+import { shelfSlots } from '@pascal-app/core';
 import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan';
 import { sanitizeShelfDimensions } from './dimensions';
 import { buildShelfFloorplan } from './floorplan';
@@ -7,7 +8,6 @@ import { buildShelfGeometry, shelfRowSurfaceYs } from './geometry';
 import { shelfPaint } from './paint';
 import { shelfParametrics } from './parametrics';
 import { ShelfNode } from './schema';
-import { shelfSlots } from './slots';
 const SIDE_HANDLE_OFFSET = 0.18;
 const HEIGHT_HANDLE_OFFSET = 0.22;
 const ROTATE_CORNER_OFFSET = 0.32;

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

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

package/dist/shelf/geometry.js

@@ -1,8 +1,7 @@
-import { SHELF_BOARD_INSET as BOARD_INSET, getMaterialPresetByRef, shelfBoardDimensions, } from '@pascal-app/core';
+import { SHELF_BOARD_INSET as BOARD_INSET, getMaterialPresetByRef, SHELF_SLOT_DEFAULT_COLOR, shelfBoardDimensions, } from '@pascal-app/core';
 import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, resolveMaterialRef, } from '@pascal-app/viewer';
 import { BoxGeometry, Group, Mesh } from 'three';
 import { sanitizeShelfDimensions } from './dimensions';
-import { SHELF_SLOT_DEFAULT_COLOR } from './slots';
 function getShelfSlotMaterial(node, slotId, materials, shading) {
     const ref = node.slots?.[slotId];
     if (ref) {

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/shelf/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AAmLzB,eAAO,MAAM,UAAU,EAAE,eA0BxB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/shelf/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AAmLzB,eAAO,MAAM,UAAU,EAAE,eAoBxB,CAAA"}

package/dist/shelf/paint.js

@@ -1,4 +1,4 @@
-import { generateSceneMaterialId, parseMaterialRef, toSceneMaterialRef, useScene, } from '@pascal-app/core';
+import { generateSceneMaterialId, slotPaintMaterial, toSceneMaterialRef, useScene, } from '@pascal-app/core';
 import { createMaterial, createMaterialFromPresetRef, useViewer } from '@pascal-app/viewer';
 function deepEqual(a, b) {
     if (Object.is(a, b))
@@ -162,15 +162,9 @@ export const shelfPaint = {
     applyPreview: ({ role, root, material, materialPreset }) => applyShelfPreview(role, root, material, materialPreset),
     getEffectiveMaterial: ({ node, role }) => {
         const shelf = node;
-        const parsed = parseMaterialRef(shelf.slots?.[role]);
-        if (parsed) {
-            if (parsed.kind === 'library') {
-                return { material: undefined, materialPreset: shelf.slots?.[role] };
-            }
-            const sceneMaterial = useScene.getState().materials[parsed.id];
-            if (sceneMaterial)
-                return { material: sceneMaterial.material, materialPreset: undefined };
-        }
+        const painted = slotPaintMaterial(shelf.slots?.[role], useScene.getState().materials);
+        if (painted)
+            return painted;
         // No (or dangling) slot ref — surface the legacy whole-shelf paint the
         // geometry builder still falls back to, so the picker matches what renders.
         if (shelf.materialPreset || shelf.material) {

package/dist/site/line-ribbon.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A patterned RIBBON along a draped polyline — the way a property line or a
+ * setback line is drawn on the ground in 3D. WebGL ignores line widths, so
+ * a thick line is a flat mesh: the polyline (already draped on the terrain
+ * by `buildDrapedPolyline`) is walked by arc length, the on / off pattern
+ * is unrolled along it (metres: dash, gap, dot, gap, dot, gap — the
+ * standard property line; dash, gap — a setback), and every "on" run
+ * becomes quads `width` wide lying flat in the XZ plane at the draped
+ * height. Pure; the renderer wraps the geometry in a mesh.
+ *
+ * The property line draws dark and thick in the standard dash-dot-dot
+ * pattern; the setbacks draw black and dashed.
+ */
+import { type TerrainField } from '@pascal-app/core';
+import { BufferGeometry } from 'three';
+/** The standard property line: a long dash, two dots (metres). */
+export declare const PROPERTY_LINE_PATTERN: readonly number[];
+/** A setback line: dashed. */
+export declare const SETBACK_LINE_PATTERN: readonly number[];
+/**
+ * Re-drape a ribbon on a changed field: every vertex keeps its XZ and takes
+ * the ground's height there plus `lift` (a sculpt stroke mid-flight).
+ */
+export declare function updateRibbonHeights(geometry: BufferGeometry, field: TerrainField | null, lift: number): void;
+/**
+ * Build the ribbon. `positions` is the draped polyline (xyz per vertex,
+ * consecutive, NOT closed — pass the closing vertex yourself); `pattern`
+ * alternates on / off lengths in metres; `width` is the ribbon's full width.
+ */
+export declare function buildPatternedRibbon(positions: Float32Array, pattern: readonly number[], width: number, step?: number): BufferGeometry;
+//# sourceMappingURL=line-ribbon.d.ts.map

package/dist/site/line-ribbon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-ribbon.d.ts","sourceRoot":"","sources":["../../src/site/line-ribbon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,EAAmB,cAAc,EAAE,MAAM,OAAO,CAAA;AAEvD,kEAAkE;AAClE,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAAqC,CAAA;AACxF,8BAA8B;AAC9B,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAAe,CAAA;AAyBjE;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,YAAY,GAAG,IAAI,EAC1B,IAAI,EAAE,MAAM,GACX,IAAI,CAWN;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,YAAY,EACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,KAAK,EAAE,MAAM,EACb,IAAI,SAAO,GACV,cAAc,CAmDhB"}

package/dist/site/line-ribbon.js

@@ -0,0 +1,117 @@
+/**
+ * A patterned RIBBON along a draped polyline — the way a property line or a
+ * setback line is drawn on the ground in 3D. WebGL ignores line widths, so
+ * a thick line is a flat mesh: the polyline (already draped on the terrain
+ * by `buildDrapedPolyline`) is walked by arc length, the on / off pattern
+ * is unrolled along it (metres: dash, gap, dot, gap, dot, gap — the
+ * standard property line; dash, gap — a setback), and every "on" run
+ * becomes quads `width` wide lying flat in the XZ plane at the draped
+ * height. Pure; the renderer wraps the geometry in a mesh.
+ *
+ * The property line draws dark and thick in the standard dash-dot-dot
+ * pattern; the setbacks draw black and dashed.
+ */
+import { surfaceHeightAt } from '@pascal-app/core';
+import { BufferAttribute, BufferGeometry } from 'three';
+/** The standard property line: a long dash, two dots (metres). */
+export const PROPERTY_LINE_PATTERN = [3.0, 0.6, 0.35, 0.6, 0.35, 0.6];
+/** A setback line: dashed. */
+export const SETBACK_LINE_PATTERN = [1.2, 0.6];
+/** The draped polyline's vertices, xyz per vertex. */
+function vertexAt(positions, i) {
+    return [positions[i * 3] ?? 0, positions[i * 3 + 1] ?? 0, positions[i * 3 + 2] ?? 0];
+}
+/** Point at arc length `s` along the polyline (plan length), with the local XZ direction. */
+function sample(positions, cum, s) {
+    const count = cum.length;
+    let i = 0;
+    while (i + 1 < count - 1 && cum[i + 1] < s)
+        i++;
+    const a = vertexAt(positions, i);
+    const b = vertexAt(positions, Math.min(count - 1, i + 1));
+    const seg = cum[i + 1] - cum[i];
+    const t = seg > 1e-9 ? Math.max(0, Math.min(1, (s - cum[i]) / seg)) : 0;
+    const p = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+    const dx = b[0] - a[0];
+    const dz = b[2] - a[2];
+    const len = Math.hypot(dx, dz) || 1;
+    return { p, d: [dx / len, dz / len] };
+}
+/**
+ * Re-drape a ribbon on a changed field: every vertex keeps its XZ and takes
+ * the ground's height there plus `lift` (a sculpt stroke mid-flight).
+ */
+export function updateRibbonHeights(geometry, field, lift) {
+    const attribute = geometry.getAttribute('position');
+    if (!attribute)
+        return;
+    const array = attribute.array;
+    for (let i = 0; i < attribute.count; i++) {
+        const x = array[i * 3] ?? 0;
+        const z = array[i * 3 + 2] ?? 0;
+        array[i * 3 + 1] = field ? surfaceHeightAt(field, x, z) + lift : lift;
+    }
+    attribute.needsUpdate = true;
+    geometry.computeBoundingSphere();
+}
+/**
+ * Build the ribbon. `positions` is the draped polyline (xyz per vertex,
+ * consecutive, NOT closed — pass the closing vertex yourself); `pattern`
+ * alternates on / off lengths in metres; `width` is the ribbon's full width.
+ */
+export function buildPatternedRibbon(positions, pattern, width, step = 0.25) {
+    const count = Math.floor(positions.length / 3);
+    const geometry = new BufferGeometry();
+    if (count < 2 || pattern.length < 2)
+        return geometry;
+    // cumulative PLAN arc length per vertex
+    const cum = [0];
+    for (let i = 1; i < count; i++) {
+        const a = vertexAt(positions, i - 1);
+        const b = vertexAt(positions, i);
+        cum.push(cum[i - 1] + Math.hypot(b[0] - a[0], b[2] - a[2]));
+    }
+    const total = cum[count - 1];
+    if (total < 1e-6)
+        return geometry;
+    const period = pattern.reduce((s, v) => s + v, 0);
+    if (period <= 0)
+        return geometry;
+    const verts = [];
+    const index = [];
+    const half = width / 2;
+    // walk the pattern along the line; each "on" run is a strip of quads
+    let s = 0;
+    let k = 0;
+    while (s < total) {
+        const len = pattern[k % pattern.length];
+        const on = k % 2 === 0;
+        const s0 = s;
+        const s1 = Math.min(total, s + len);
+        if (on && s1 - s0 > 1e-6) {
+            // subdivide the run so it follows corners and the drape
+            const n = Math.max(1, Math.ceil((s1 - s0) / step));
+            const base = verts.length / 3;
+            for (let j = 0; j <= n; j++) {
+                const { p, d } = sample(positions, cum, s0 + ((s1 - s0) * j) / n);
+                // the ribbon's normal in plan is the line direction turned 90°
+                const nx = -d[1] * half;
+                const nz = d[0] * half;
+                verts.push(p[0] + nx, p[1], p[2] + nz, p[0] - nx, p[1], p[2] - nz);
+            }
+            for (let j = 0; j < n; j++) {
+                const a = base + j * 2;
+                index.push(a, a + 1, a + 2, a + 1, a + 3, a + 2);
+            }
+        }
+        s = s1;
+        k++;
+        if (k > 100000)
+            break;
+    }
+    geometry.setAttribute('position', new BufferAttribute(new Float32Array(verts), 3));
+    geometry.setIndex(index);
+    geometry.computeVertexNormals();
+    geometry.computeBoundingSphere();
+    return geometry;
+}

package/dist/site/lot-mask.d.ts

@@ -0,0 +1,18 @@
+import type { Material } from 'three';
+import type { Node } from 'three/webgpu';
+type Point = readonly [number, number];
+/**
+ * True for a fragment inside the lot polygon (even-odd crossing count on its
+ * local x, z). Unrolled edge by edge into the graph: a parcel has tens of
+ * corners, so a loop and a uniform array would buy nothing.
+ */
+export declare function insideLotNode(polygon: ReadonlyArray<Point>): Node<"bool">;
+/**
+ * The ground material cut to the lot: the terrain field is the padded,
+ * north-up box around the parcel, and only the parcel itself is ground the
+ * project owns. Per fragment, so the edge is the property line exactly and
+ * follows a sculpt stroke with no rebuild; the shadow pass honours the mask too.
+ */
+export declare function lotMaskedMaterial(material: Material, polygon: ReadonlyArray<Point>): Material;
+export {};
+//# sourceMappingURL=lot-mask.d.ts.map

package/dist/site/lot-mask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lot-mask.d.ts","sourceRoot":"","sources":["../../src/site/lot-mask.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAErC,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,cAAc,CAAA;AAEtD,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEtC;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,gBAgB1D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,QAAQ,CAI7F"}

package/dist/site/lot-mask.js

@@ -0,0 +1,35 @@
+import { float, mod, positionLocal, select } from 'three/tsl';
+/**
+ * True for a fragment inside the lot polygon (even-odd crossing count on its
+ * local x, z). Unrolled edge by edge into the graph: a parcel has tens of
+ * corners, so a loop and a uniform array would buy nothing.
+ */
+export function insideLotNode(polygon) {
+    const at = positionLocal.xz;
+    let crossings = float(0);
+    for (let i = 0; i < polygon.length; i++) {
+        const [ax, az] = polygon[i];
+        const [bx, bz] = polygon[(i + 1) % polygon.length];
+        if (az === bz)
+            continue;
+        const slope = (bx - ax) / (bz - az);
+        const crossesAt = at.y.sub(az).mul(slope).add(ax);
+        const crosses = at.y
+            .greaterThanEqual(Math.min(az, bz))
+            .and(at.y.lessThan(Math.max(az, bz)))
+            .and(at.x.lessThan(crossesAt));
+        crossings = crossings.add(select(crosses, float(1), float(0)));
+    }
+    return mod(crossings, float(2)).greaterThan(0.5);
+}
+/**
+ * The ground material cut to the lot: the terrain field is the padded,
+ * north-up box around the parcel, and only the parcel itself is ground the
+ * project owns. Per fragment, so the edge is the property line exactly and
+ * follows a sculpt stroke with no rebuild; the shadow pass honours the mask too.
+ */
+export function lotMaskedMaterial(material, polygon) {
+    const masked = material.clone();
+    masked.maskNode = insideLotNode(polygon);
+    return masked;
+}

package/dist/site/panel.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Site inspector — address → real parcel, plus the zoning inputs the site
+ * plan draws from. Mounted through `siteParametrics.customPanel`.
+ *
+ * The address lookup goes through the host's parcel provider
+ * (`setParcelProvider`) and is hidden when the host has none.
+ */
+export declare function SiteNodePanel(): import("react").JSX.Element | null;
+export default SiteNodePanel;
+//# sourceMappingURL=panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/site/panel.tsx"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,wBAAgB,aAAa,uCA8T5B;AAWD,eAAe,aAAa,CAAA"}

package/dist/site/panel.js

@@ -0,0 +1,155 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useScene } from '@pascal-app/core';
+import { ActionButton, ActionGroup, describeSiteEdges, dropInLot, PanelSection, PanelWrapper, useParcelProvider, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { MapPin, Search } from 'lucide-react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+const METRES_PER_FOOT = 0.3048;
+/**
+ * Site inspector — address → real parcel, plus the zoning inputs the site
+ * plan draws from. Mounted through `siteParametrics.customPanel`.
+ *
+ * The address lookup goes through the host's parcel provider
+ * (`setParcelProvider`) and is hidden when the host has none.
+ */
+export function SiteNodePanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    // The selected site node, else THE site node: the sidebar's Site header
+    // mounts this panel directly, where nothing may be selected.
+    const node = useScene((s) => {
+        const selected = selectedId
+            ? s.nodes[selectedId]
+            : undefined;
+        if (selected?.type === 'site')
+            return selected;
+        for (const id of s.rootNodeIds) {
+            const n = s.nodes[id];
+            if (n?.type === 'site')
+                return n;
+        }
+        return undefined;
+    });
+    const [query, setQuery] = useState('');
+    const [suggestions, setSuggestions] = useState([]);
+    const [picked, setPicked] = useState(null);
+    const [status, setStatus] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const requestSeq = useRef(0);
+    const parcelProvider = useParcelProvider();
+    const update = useCallback((patch) => {
+        if (!node)
+            return;
+        useScene.getState().updateNode(node.id, patch);
+    }, [node]);
+    // Seed the address box from the node so reopening the panel shows what the
+    // lot was resolved from.
+    useEffect(() => {
+        if (!node?.address)
+            return;
+        const parts = [node.address.street, node.address.city, node.address.state, node.address.zip];
+        setQuery((current) => current || parts.filter(Boolean).join(', '));
+    }, [node?.address]);
+    // Debounced autocomplete. `seq` guards against an earlier response landing
+    // after a later one.
+    useEffect(() => {
+        const q = query.trim();
+        if (!parcelProvider || q.length < 4 || picked) {
+            setSuggestions([]);
+            return;
+        }
+        const seq = ++requestSeq.current;
+        const timer = setTimeout(() => {
+            parcelProvider('autocomplete', { q })
+                .then((data) => {
+                if (seq !== requestSeq.current)
+                    return;
+                const list = data?.suggestions;
+                setSuggestions(Array.isArray(list) ? list : []);
+            })
+                .catch(() => {
+                if (seq === requestSeq.current)
+                    setSuggestions([]);
+            });
+        }, 300);
+        return () => clearTimeout(timer);
+    }, [parcelProvider, query, picked]);
+    const edges = useMemo(() => describeSiteEdges(node ?? null), [node]);
+    // One engine for every path (Lot panel, Generate, here): resolve the
+    // parcel, map the streets, pick the street-facing edge, default the
+    // setbacks when the site has none, re-centre a building that fell outside
+    // the new ring. See @pascal-app/editor `dropInLot`.
+    const findParcel = useCallback(async () => {
+        if (!node)
+            return;
+        const address = query.trim();
+        if (!address) {
+            setStatus('Type an address first.');
+            return;
+        }
+        setBusy(true);
+        setStatus('Looking up the parcel and the streets around it…');
+        try {
+            const result = await dropInLot({
+                address,
+                ...(picked?.lat != null && picked?.lng != null
+                    ? { latitude: picked.lat, longitude: picked.lng, state: picked.state }
+                    : {}),
+                street: picked?.line1,
+                city: picked?.city,
+                zip: picked?.postcode,
+            }, { siteId: node.id });
+            setStatus(result.message);
+        }
+        catch (error) {
+            setStatus(error instanceof Error ? error.message : 'Parcel lookup failed.');
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [node, picked, query]);
+    if (!node)
+        return null;
+    const setbacks = node.setbacks;
+    const setbackField = (key, label, optional = false) => (_jsxs("label", { className: "flex items-center justify-between gap-3 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: label }), _jsxs("span", { className: "flex items-center gap-1", children: [_jsx("input", { className: "w-20 rounded-md border border-border/70 bg-background px-2 py-1 text-right text-foreground", defaultValue: setbacks?.[key] != null
+                            ? String(Math.round((setbacks[key] / METRES_PER_FOOT) * 10) / 10)
+                            : '', inputMode: "decimal", onFocus: (event) => event.target.select(), onBlur: (event) => {
+                            const raw = event.target.value.trim();
+                            if (raw === '' && optional) {
+                                const next = { ...(setbacks ?? { front: 0, rear: 0, side: 0 }) };
+                                delete next[key];
+                                update({ setbacks: next });
+                                return;
+                            }
+                            const feet = Number(raw);
+                            if (!Number.isFinite(feet) || feet < 0)
+                                return;
+                            update({
+                                setbacks: {
+                                    ...(setbacks ?? { front: 0, rear: 0, side: 0 }),
+                                    [key]: feet * METRES_PER_FOOT,
+                                },
+                            });
+                        }, placeholder: optional ? 'side' : '0' }, `${key}-${setbacks?.[key] ?? 'none'}`), _jsx("span", { className: "text-muted-foreground text-xs", children: "ft" })] })] }, key));
+    return (_jsxs(PanelWrapper, { title: "Site", children: [parcelProvider ? (_jsxs(PanelSection, { title: "Address", children: [_jsxs("label", { className: "space-y-1 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: "Street address" }), _jsx("input", { className: "w-full rounded-md border border-border/70 bg-background px-2 py-1.5 text-foreground", onChange: (event) => {
+                                    setQuery(event.target.value);
+                                    setPicked(null);
+                                }, placeholder: "1200 W Cass St, Tampa, FL", value: query })] }), suggestions.length > 0 ? (_jsx("ul", { className: "max-h-44 space-y-0.5 overflow-y-auto rounded-md border border-border/70 bg-card p-1", children: suggestions.map((s) => (_jsx("li", { children: _jsxs("button", { className: "flex w-full items-start gap-2 rounded px-2 py-1.5 text-left text-foreground text-xs hover:bg-muted", onClick: () => {
+                                    setPicked(s);
+                                    setQuery(s.label ?? [s.line1, s.line2].filter(Boolean).join(', '));
+                                    setSuggestions([]);
+                                }, type: "button", children: [_jsx(MapPin, { className: "mt-0.5 size-3 shrink-0 text-muted-foreground" }), _jsx("span", { children: s.label ?? [s.line1, s.line2].filter(Boolean).join(', ') })] }) }, `${s.label}-${s.lat}-${s.lng}`))) })) : null, _jsx(ActionGroup, { children: _jsx(ActionButton, { disabled: busy, icon: _jsx(Search, { className: "size-4" }), label: busy ? 'Finding…' : 'Find parcel', onClick: findParcel }) }), status ? _jsx("p", { className: "text-muted-foreground text-xs", children: status }) : null] })) : null, node.parcel ? (_jsxs(PanelSection, { title: "Parcel", children: [_jsx(Row, { label: "APN", value: node.parcel.apn || '—' }), _jsx(Row, { label: "County", value: node.parcel.county || '—' }), _jsx(Row, { label: "Lot area", value: node.parcel.lotAreaSqFt
+                            ? `${Math.round(node.parcel.lotAreaSqFt).toLocaleString()} sq ft`
+                            : '—' }), _jsx(Row, { label: "Source", value: node.parcel.layer || node.parcel.source || '—' }), node.parcel.notes?.length ? (_jsx("p", { className: "text-muted-foreground text-xs leading-snug", children: node.parcel.notes.join(' ') })) : null] })) : null, _jsxs(PanelSection, { title: "Setbacks", children: [setbackField('front', 'Front'), setbackField('side', 'Side'), setbackField('rear', 'Rear'), setbackField('left', 'Left (override)', true), setbackField('right', 'Right (override)', true), _jsxs("label", { className: "space-y-1 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: "Source / citation" }), _jsx("input", { className: "w-full rounded-md border border-border/70 bg-background px-2 py-1.5 text-foreground", defaultValue: node.setbacksSource ?? '', onBlur: (event) => update({ setbacksSource: event.target.value || undefined }), placeholder: "e.g. Tampa LDC \u00A727-156" }, node.setbacksSource ?? '')] }), _jsxs("label", { className: "space-y-1 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: "Zone" }), _jsx("input", { className: "w-full rounded-md border border-border/70 bg-background px-2 py-1.5 text-foreground", defaultValue: node.zone ?? '', onBlur: (event) => update({ zone: event.target.value || undefined }), placeholder: "e.g. RS-60" }, node.zone ?? '')] })] }), _jsxs(PanelSection, { title: "Terrain", children: [_jsxs("label", { className: "space-y-1 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: "Contour interval (site plan and 3D)" }), _jsxs("select", { className: "w-full rounded-md border border-border/70 bg-background px-2 py-1.5 text-foreground", onChange: (event) => update({ contourIntervalIn: Number(event.target.value) }), value: String(node.contourIntervalIn ?? 12), children: [_jsx("option", { value: "0", children: "none" }), _jsx("option", { value: "6", children: "every 6 in" }), _jsx("option", { value: "12", children: "every 12 in" }), _jsx("option", { value: "24", children: "every 24 in" })] })] }), _jsxs("label", { className: "flex items-center gap-2 text-sm", children: [_jsx("input", { checked: node.contours3d ?? false, onChange: (event) => update({ contours3d: event.target.checked }), type: "checkbox" }), _jsx("span", { className: "text-muted-foreground", children: "Show the contour lines in 3D" })] }), node.terrainContours ? (_jsxs("p", { className: "text-muted-foreground text-xs", children: [node.terrainContours.lines.length, " surveyed lines at ", node.terrainContours.intervalFt, ' ', "ft (", node.terrainContours.datum, ") \u2014 ", node.terrainContours.source ?? 'survey'] })) : (_jsx("p", { className: "text-muted-foreground text-xs", children: "No surveyed lines \u2014 contours are drawn from the sculpted ground." }))] }), _jsxs(PanelSection, { title: "Orientation", children: [_jsxs("label", { className: "space-y-1 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: "Front (street) edge" }), _jsxs("select", { className: "w-full rounded-md border border-border/70 bg-background px-2 py-1.5 text-foreground", onChange: (event) => update({
+                                    frontEdge: event.target.value === '' ? undefined : Number(event.target.value),
+                                }), value: node.frontEdge == null ? '' : String(node.frontEdge), children: [_jsx("option", { value: "", children: "Auto \u2014 most north-facing edge" }), edges.map((edge) => (_jsx("option", { value: String(edge.index), children: edge.label }, edge.index)))] })] }), _jsxs("label", { className: "flex items-center justify-between gap-3 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: "North rotation" }), _jsxs("span", { className: "flex items-center gap-1", children: [_jsx("input", { className: "w-20 rounded-md border border-border/70 bg-background px-2 py-1 text-right text-foreground", defaultValue: String(Math.round((((node.northRotation ?? 0) * 180) / Math.PI) * 10) / 10), inputMode: "decimal", onFocus: (event) => event.target.select(), onBlur: (event) => {
+                                            const deg = Number(event.target.value.trim());
+                                            if (!Number.isFinite(deg))
+                                                return;
+                                            update({ northRotation: (deg * Math.PI) / 180 });
+                                        } }, String(node.northRotation ?? 0)), _jsx("span", { className: "text-muted-foreground text-xs", children: "\u00B0" })] })] })] })] }));
+}
+function Row({ label, value }) {
+    return (_jsxs("div", { className: "flex items-center justify-between gap-3 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: label }), _jsx("span", { className: "truncate font-medium text-foreground", children: value })] }));
+}
+export default SiteNodePanel;

package/dist/site/parametrics.d.ts

@@ -1,3 +1,10 @@
 import type { ParametricDescriptor, SiteNode } from '@pascal-app/core';
+/**
+ * Inspector descriptor for site.
+ *
+ * `customPanel` mounts `<SitePanel>` — address autocomplete, the parcel
+ * lookup, setbacks and the front-edge picker need async network state and
+ * feet↔metres conversion that the auto-derived field kinds don't cover.
+ */
 export declare const siteParametrics: ParametricDescriptor<SiteNode>;
 //# sourceMappingURL=parametrics.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/site/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEtE,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAE1D,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/site/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEtE;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAG1D,CAAA"}