@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/shelf/definition.js

@@ -1,13 +1,13 @@
-import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan';
-import { sanitizeShelfDimensions } from './dimensions';
-import { buildShelfFloorplan } from './floorplan';
-import { shelfResizeAffordance, shelfRotateAffordance } from './floorplan-affordances';
-import { shelfFloorplanMoveTarget } from './floorplan-move';
-import { buildShelfGeometry, shelfRowSurfaceYs } from './geometry';
-import { shelfPaint } from './paint';
-import { shelfParametrics } from './parametrics';
-import { ShelfNode } from './schema';
-import { shelfSlots } from './slots';
+import { shelfSlots } from '@pascal-app/core';
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan.js';
+import { sanitizeShelfDimensions } from './dimensions.js';
+import { buildShelfFloorplan } from './floorplan.js';
+import { shelfResizeAffordance, shelfRotateAffordance } from './floorplan-affordances.js';
+import { shelfFloorplanMoveTarget } from './floorplan-move.js';
+import { buildShelfGeometry, shelfRowSurfaceYs } from './geometry.js';
+import { shelfPaint } from './paint.js';
+import { shelfParametrics } from './parametrics.js';
+import { ShelfNode } from './schema.js';
 const SIDE_HANDLE_OFFSET = 0.18;
 const HEIGHT_HANDLE_OFFSET = 0.22;
 const ROTATE_CORNER_OFFSET = 0.32;
@@ -154,6 +154,8 @@ export const shelfDefinition = {
         // catalog materials into `slots`.
     }),
     capabilities: {
+        reveal: { phase: 'furnishing', style: 'drop', height: 0.3 },
+        revealOnEdit: ['width', 'depth', 'height', 'thickness', 'rows', 'columns', 'style'],
         movable: { axes: ['x', 'z'], gridSnap: true },
         rotatable: {
             axes: ['y'],
@@ -249,8 +251,8 @@ export const shelfDefinition = {
         'shelf-resize': shelfResizeAffordance,
         'shelf-rotate': shelfRotateAffordance,
     },
-    preview: () => import('./preview'),
-    tool: () => import('./tool'),
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
     toolHints: [
         { key: 'Left click', label: 'Place shelf' },
         { key: 'Esc', label: 'Cancel' },

package/dist/shelf/dimensions.d.ts

@@ -1,3 +1,3 @@
-import type { ShelfNode } from './schema';
+import type { ShelfNode } from './schema.js';
 export declare function sanitizeShelfDimensions(node: ShelfNode): ShelfNode;
 //# sourceMappingURL=dimensions.d.ts.map

package/dist/shelf/floorplan-affordances.js

@@ -1,6 +1,6 @@
 import { cascadeDirty, createSceneApi, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { isAngleSnapActive } from '@pascal-app/editor';
-import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance.js';
 // Mirror the 3D handles in `shelf/definition.ts` so a drag can't push a
 // value past what the renderer / geometry builder accepts.
 const MIN_SHELF_WIDTH = 0.3;

package/dist/shelf/floorplan-move.js

@@ -1,6 +1,6 @@
 import { cascadeDirty, collectAlignmentAnchors, createSceneApi, movingFootprintAnchors, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { applyFloorplanAlignment, getFloorStackPreviewPosition, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, triggerSFX, } from '@pascal-app/editor';
-import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.js';
 /**
  * 2D floor-plan move handler for shelf — mirrors `itemFloorplanMoveTarget`,
  * because shelf is a `position`-field kind (it carries its location in

package/dist/shelf/floorplan.d.ts

@@ -1,5 +1,5 @@
 import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
-import type { ShelfNode } from './schema';
+import type { ShelfNode } from './schema.js';
 /**
  * 2D floor-plan representation of a shelf. The unit's outer footprint
  * projects to a rectangle of `width × depth` centered on the shelf's

package/dist/shelf/floorplan.js

@@ -1,5 +1,5 @@
-import { restingNodePlanFrame } from '../shared/resting-surface-plan';
-import { sanitizeShelfDimensions } from './dimensions';
+import { restingNodePlanFrame } from '../shared/resting-surface-plan.js';
+import { sanitizeShelfDimensions } from './dimensions.js';
 // Offsets for the floor-plan selection chrome. Resize chevrons sit a
 // hair off the footprint rim; the rotate-arrow corner sits a bit further
 // out so it doesn't crowd the resize arrows.

package/dist/shelf/geometry.d.ts

@@ -1,7 +1,7 @@
 import { type GeometryContext } from '@pascal-app/core';
 import { type RenderShading } from '@pascal-app/viewer';
 import { Group } from 'three';
-import type { ShelfNode } from './schema';
+import type { ShelfNode } from './schema.js';
 export declare function buildShelfGeometry(rawNode: ShelfNode, ctx?: GeometryContext, shading?: RenderShading): Group;
 /**
  * Y of the top surface of each shelf row (top of the board). Used by

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';
+import { sanitizeShelfDimensions } from './dimensions.js';
 function getShelfSlotMaterial(node, slotId, materials, shading) {
     const ref = node.slots?.[slotId];
     if (ref) {

package/dist/shelf/index.d.ts

@@ -1,4 +1,4 @@
-export { shelfDefinition } from './definition';
-export { buildShelfGeometry } from './geometry';
-export { ShelfNode } from './schema';
+export { shelfDefinition } from './definition.js';
+export { buildShelfGeometry } from './geometry.js';
+export { ShelfNode } from './schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/shelf/index.js

@@ -1,3 +1,3 @@
-export { shelfDefinition } from './definition';
-export { buildShelfGeometry } from './geometry';
-export { ShelfNode } from './schema';
+export { shelfDefinition } from './definition.js';
+export { buildShelfGeometry } from './geometry.js';
+export { ShelfNode } from './schema.js';

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/shelf/parametrics.d.ts

@@ -1,5 +1,5 @@
 import type { ParametricDescriptor } from '@pascal-app/core';
-import type { ShelfNode } from './schema';
+import type { ShelfNode } from './schema.js';
 /**
  * Inspector descriptor for the parametric shelf. Drives both the
  * auto-derived inspector UI and the AI/MCP `create_shelf` /

package/dist/shelf/preview.d.ts

@@ -1,4 +1,4 @@
-import type { ShelfNode } from './schema';
+import type { ShelfNode } from './schema.js';
 /**
  * Translucent preview of a shelf — used by the placement tool's cursor
  * and the registry mover. Defers to `buildShelfGeometry` so the preview

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

@@ -1 +1 @@
-{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/shelf/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAiDlD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/shelf/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,QAAA,MAAM,YAAY,aAAc;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAiDlD,CAAA;eAEc,YAAY"}

package/dist/shelf/preview.js

@@ -2,7 +2,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo } from 'react';
-import { buildShelfGeometry } from './geometry';
+import { buildShelfGeometry } from './geometry.js';
 /**
  * Translucent preview of a shelf — used by the placement tool's cursor
  * and the registry mover. Defers to `buildShelfGeometry` so the preview

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/shelf/tool.tsx"],"names":[],"mappings":"AAiCA,QAAA,MAAM,SAAS,0CA+Id,CAAA;AAED,eAAe,SAAS,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/shelf/tool.tsx"],"names":[],"mappings":"AAiCA,QAAA,MAAM,SAAS,0CA+Id,CAAA;eAEc,SAAS"}

package/dist/shelf/tool.js

@@ -4,9 +4,9 @@ import { collectAlignmentAnchors, emitter, resolveSupportSlabPatch, ShelfNode, u
 import { getFloorStackPreviewPosition, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, movementSfxStepKey, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { getLevelLocalSnappedPosition, resolveAlignedFloorPlacement, stopPlacementCommitPropagation, subscribeFloorPlacementClicks, } from '../shared/floor-placement';
-import { shelfDefinition } from './definition';
-import ShelfPreview from './preview';
+import { getLevelLocalSnappedPosition, resolveAlignedFloorPlacement, stopPlacementCommitPropagation, subscribeFloorPlacementClicks, } from '../shared/floor-placement.js';
+import { shelfDefinition } from './definition.js';
+import ShelfPreview from './preview.js';
 const ShelfTool = () => {
     const activeLevelId = useViewer((state) => state.selection.levelId);
     const cursorRef = useRef(null);

package/dist/site/definition.d.ts

@@ -1,5 +1,5 @@
 import { type NodeDefinition } from '@pascal-app/core';
-import { SiteNode } from './schema';
+import { SiteNode } from './schema.js';
 /**
  * Site — Stage A. Top-level container under the scene root; holds
  * buildings + property-line polygon + zones. No system (sites don't

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/site/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAGlF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAkD1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/site/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAGlF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAmD1D,CAAA"}

package/dist/site/definition.js

@@ -1,7 +1,7 @@
 import { SiteNode as SiteNodeSchema } from '@pascal-app/core';
-import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
-import { siteParametrics } from './parametrics';
-import { SiteNode } from './schema';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
+import { siteParametrics } from './parametrics.js';
+import { SiteNode } from './schema.js';
 /**
  * Site — Stage A. Top-level container under the scene root; holds
  * buildings + property-line polygon + zones. No system (sites don't
@@ -19,6 +19,7 @@ export const siteDefinition = {
         return rest;
     },
     capabilities: {
+        exterior: true,
         // Site is the root container — sidebar / property-line tool drive
         // selection, never 3D click (event bubbling from descendants would
         // override their selection). Same reasoning as `level`.
@@ -39,7 +40,7 @@ export const siteDefinition = {
     dirtyTracking: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     presentation: {
         label: 'Site',

package/dist/site/generic-foundation-geometry.d.ts

@@ -0,0 +1,16 @@
+import type { FoundationMember } from '@pascal-app/core';
+/** The foundation members of one kind as one indexed mesh, in world coordinates. */
+export type FoundationMesh = {
+    positions: Float32Array;
+    normals: Float32Array;
+    /** Metres along the run, for the courses of block to bond along the wall. */
+    along: Float32Array;
+    indices: Uint32Array;
+};
+/**
+ * The runs of `kind` as closed boxes, six faces each with its own flat normal. A run is a prism on
+ * the plan line `from` to `to`, `width` across, from `bottomY` to `topY`. Corners are closed by the
+ * runs themselves (they overlap), so the boxes carry no joins.
+ */
+export declare function buildFoundationMesh(members: readonly FoundationMember[], kind: FoundationMember['kind']): FoundationMesh | null;
+//# sourceMappingURL=generic-foundation-geometry.d.ts.map

package/dist/site/generic-foundation-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-foundation-geometry.d.ts","sourceRoot":"","sources":["../../src/site/generic-foundation-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAExD,oFAAoF;AACpF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,EAAE,YAAY,CAAA;IACrB,6EAA6E;IAC7E,KAAK,EAAE,YAAY,CAAA;IACnB,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAYD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAC7B,cAAc,GAAG,IAAI,CA6DvB"}

package/dist/site/generic-foundation-geometry.js

@@ -0,0 +1,75 @@
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const cross = (a, b) => [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+/**
+ * The runs of `kind` as closed boxes, six faces each with its own flat normal. A run is a prism on
+ * the plan line `from` to `to`, `width` across, from `bottomY` to `topY`. Corners are closed by the
+ * runs themselves (they overlap), so the boxes carry no joins.
+ */
+export function buildFoundationMesh(members, kind) {
+    const runs = members.filter((member) => member.kind === kind);
+    if (runs.length === 0)
+        return null;
+    const positions = [];
+    const normals = [];
+    const along = [];
+    const indices = [];
+    const quad = (corners, outward, alongAt) => {
+        const [a, b, c] = corners;
+        const facing = dot(cross(sub(b, a), sub(c, a)), outward) >= 0;
+        const order = facing ? [0, 1, 2, 3] : [0, 3, 2, 1];
+        const base = positions.length / 3;
+        for (const index of order) {
+            positions.push(...corners[index]);
+            normals.push(...outward);
+            along.push(alongAt[index]);
+        }
+        indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+    };
+    for (const { from, to, width, bottomY, topY } of runs) {
+        const dx = to[0] - from[0];
+        const dz = to[1] - from[1];
+        const length = Math.hypot(dx, dz);
+        if (length < 1e-9 || topY - bottomY < 1e-9)
+            continue;
+        const [ux, uz] = [dx / length, dz / length];
+        const [nx, nz] = [-uz, ux];
+        const half = width / 2;
+        const at = (end, side, y) => [
+            end[0] + nx * half * side,
+            y,
+            end[1] + nz * half * side,
+        ];
+        const [a0, a1, a2, a3] = [
+            at(from, 1, bottomY),
+            at(to, 1, bottomY),
+            at(to, -1, bottomY),
+            at(from, -1, bottomY),
+        ];
+        const [b0, b1, b2, b3] = [
+            at(from, 1, topY),
+            at(to, 1, topY),
+            at(to, -1, topY),
+            at(from, -1, topY),
+        ];
+        const run = [0, length, length, 0];
+        quad([b0, b1, b2, b3], [0, 1, 0], run);
+        quad([a0, a1, a2, a3], [0, -1, 0], run);
+        quad([a0, a1, b1, b0], [nx, 0, nz], [0, length, length, 0]);
+        quad([a3, a2, b2, b3], [-nx, 0, -nz], [0, length, length, 0]);
+        quad([a0, a3, b3, b0], [-ux, 0, -uz], [0, 0, 0, 0]);
+        quad([a1, a2, b2, b1], [ux, 0, uz], [length, length, length, length]);
+    }
+    if (indices.length === 0)
+        return null;
+    return {
+        positions: new Float32Array(positions),
+        normals: new Float32Array(normals),
+        along: new Float32Array(along),
+        indices: new Uint32Array(indices),
+    };
+}

package/dist/site/generic-foundation.d.ts

@@ -0,0 +1,4 @@
+import { type FoundationMember } from '@pascal-app/core';
+export declare function sameFoundation(a: readonly FoundationMember[], b: readonly FoundationMember[]): boolean;
+export declare function GenericFoundation(): import("react").JSX.Element;
+//# sourceMappingURL=generic-foundation.d.ts.map

package/dist/site/generic-foundation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-foundation.d.ts","sourceRoot":"","sources":["../../src/site/generic-foundation.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,gBAAgB,EAKtB,MAAM,kBAAkB,CAAA;AAoDzB,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,gBAAgB,EAAE,EAAE,CAAC,EAAE,SAAS,gBAAgB,EAAE,WAoB5F;AAwCD,wBAAgB,iBAAiB,gCA8BhC"}

package/dist/site/generic-foundation.js

@@ -0,0 +1,91 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { genericFoundation, isCaptureSessionOn, subscribeCaptureSessions, useScene, } from '@pascal-app/core';
+import { BLOCK_MASONRY, concreteMaterial, masonryMaterial, SITE_FOUNDATION, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+import { BufferAttribute, BufferGeometry } from 'three';
+import { buildFoundationMesh } from './generic-foundation-geometry.js';
+import { noopRaycast } from './ground-veil.js';
+/**
+ * The generic foundation under the buildings (`genericFoundation` in core): a concrete footing and
+ * a foundation wall, drawn from the walls and never stored, of the building's foundation
+ * construction: block by default, cast concrete in Europe (each stem run carries its `material`). It is always drawn: the ground hides the part below it from above
+ * (the eye under the ground, or looking through the hole over a level below grade, is what sees
+ * it), and the course the building's seat leaves above grade reads as what it is built of in the
+ * normal view. The walkthrough draws none of it.
+ *
+ * One mesh per material in use, the materials made once; nothing about them depends on the level
+ * shown or on where the eye is, so a floor switch or a dive compiles nothing. Geometry is rebuilt
+ * only when the foundation itself changes, or when a plugin takes a level's foundation over under
+ * the ground (`pluginFoundationLevelIds`): that level's members leave the geometry while it draws
+ * them.
+ */
+function geometryOf(mesh) {
+    if (!mesh)
+        return null;
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new BufferAttribute(mesh.positions, 3));
+    geometry.setAttribute('normal', new BufferAttribute(mesh.normals, 3));
+    geometry.setAttribute('along', new BufferAttribute(mesh.along, 1));
+    geometry.setIndex(new BufferAttribute(mesh.indices, 1));
+    return geometry;
+}
+/** The stem runs built of `material` as one geometry. */
+function stemGeometry(members, material) {
+    return geometryOf(buildFoundationMesh(members.filter((member) => member.material === material), 'stem'));
+}
+export function sameFoundation(a, b) {
+    return (a.length === b.length &&
+        a.every((member, index) => {
+            const other = b[index];
+            return (other !== undefined &&
+                member.kind === other.kind &&
+                member.material === other.material &&
+                member.levelId === other.levelId &&
+                member.width === other.width &&
+                member.bottomY === other.bottomY &&
+                member.topY === other.topY &&
+                member.from[0] === other.from[0] &&
+                member.from[1] === other.from[1] &&
+                member.to[0] === other.to[0] &&
+                member.to[1] === other.to[1]);
+        }));
+}
+function useFoundationMembers() {
+    // Stable across store writes that leave the foundation as it was.
+    const kept = useRef([]);
+    // A capture session starting or ending changes what a plugin claims, though no node changes:
+    // the picture shows the finished house, with the generic course a framing plugin gives back.
+    useSyncExternalStore(subscribeCaptureSessions, isCaptureSessionOn, () => false);
+    return useScene((state) => {
+        const next = genericFoundation(state.nodes);
+        if (sameFoundation(next, kept.current))
+            return kept.current;
+        kept.current = next;
+        return next;
+    });
+}
+function FoundationPart({ geometry, material, visible, part, }) {
+    useEffect(() => () => geometry?.dispose(), [geometry]);
+    if (!geometry)
+        return null;
+    return (_jsx("mesh", { geometry: geometry, material: material, raycast: noopRaycast, userData: { [SITE_FOUNDATION]: true, genericFoundation: part, pascalExport: 'strip' }, visible: visible }));
+}
+export function GenericFoundation() {
+    const derived = useFoundationMembers();
+    const takenOver = useViewer((state) => state.pluginFoundationLevelIds);
+    const members = useMemo(() => takenOver.length === 0
+        ? derived
+        : derived.filter((member) => !takenOver.includes(member.levelId)), [derived, takenOver]);
+    const shown = useViewer((state) => !state.walkthroughMode);
+    const concrete = useMemo(concreteMaterial, []);
+    const block = useMemo(() => masonryMaterial(BLOCK_MASONRY), []);
+    useEffect(() => () => {
+        concrete.dispose();
+        block.dispose();
+    }, [concrete, block]);
+    const footing = useMemo(() => geometryOf(buildFoundationMesh(members, 'footing')), [members]);
+    const blockStem = useMemo(() => stemGeometry(members, 'cmu'), [members]);
+    const concreteStem = useMemo(() => stemGeometry(members, 'concrete'), [members]);
+    return (_jsxs(_Fragment, { children: [_jsx(FoundationPart, { geometry: footing, material: concrete, part: "footing", visible: shown }), _jsx(FoundationPart, { geometry: blockStem, material: block, part: "stem", visible: shown }), _jsx(FoundationPart, { geometry: concreteStem, material: concrete, part: "stem", visible: shown })] }));
+}

package/dist/site/ground-hole.d.ts

@@ -0,0 +1,92 @@
+import { type UndergroundEdge } from '@pascal-app/viewer';
+/**
+ * The ground as the medium, seen from above: over a level below grade the ground stays solid and
+ * a hole opens in it over the below-grade footprint, through which the level is seen clearly. The
+ * hole's edge is a noise threshold, an eroded border: the distance from the footprint is compared
+ * to a radius that wanders with a fractal perlin noise (broad waves with finer ones riding them),
+ * so the cut is a living, eroded line rather than an offset outline. Along it the ground darkens
+ * in a soft feather and a thin light line marks the cut itself.
+ *
+ * The footprint is a signed-distance field baked on the CPU into a small texture when the
+ * footprints change (the polygons the grade ring is drawn from), so the ground's mask costs one
+ * texture fetch and one noise lookup per fragment, whatever the building's outline. How far the
+ * hole is open (0 to 1, eased, 0 in a capture) is the viewer's `groundHoleOpenNode`.
+ */
+/**
+ * The shipped edge's base margin around the footprint (metres) and how far the noise moves the
+ * edge in or out of it. The edge looks (`underground-edge.ts`) vary both, and the noise's scale
+ * (cells per metre of its broadest octave, ~1.7 m waves at today's), through uniforms.
+ */
+export declare const HOLE_MARGIN: number;
+export declare const HOLE_ERODE: number;
+/**
+ * Sets the hole's edge look: the shader's margin, erosion, noise scale, feather and line (all
+ * uniforms, nothing recompiles), and the CPU's twin of them. The pit's walls are cut again by
+ * `GroundHole` after this.
+ */
+export declare function setGroundHoleEdge(edge: UndergroundEdge): void;
+type Point = readonly [number, number];
+/**
+ * Bakes the signed distance to `polygons` (the below-grade footprints, world plan) into the
+ * hole's texture. No polygons: the field is far everywhere, so the ground has no hole.
+ */
+export declare function setGroundHoleFootprints(polygons: ReadonlyArray<ReadonlyArray<Point>>): void;
+/** The baked signed distance to the footprints at a world XZ (bilinear, as the shader reads it). */
+export declare function groundHoleDistanceAt(x: number, z: number): number;
+/** The baked field's box in the world's plan, `null` while no footprint is baked. */
+export declare function groundHoleBox(): {
+    originX: number;
+    originZ: number;
+    span: number;
+} | null;
+/**
+ * The hole's radius at a world XZ at full opening, as the shader's noise gives it: what the pit's
+ * walls are laid along (`hole-noise.ts` is that noise on the CPU).
+ */
+export declare function holeRadiusAt(x: number, z: number): number;
+/**
+ * The CPU twin of the hole for one pick: whether `(x, z)` is surely in the hole now. The edge's
+ * noise is not replayed here, so this is the part of the hole that is open whatever the noise
+ * does (margin less the full erosion): a click there falls through to the floor under it, and a
+ * click in the wandering fringe still lands on the ground.
+ */
+export declare function groundHoleContains(x: number, z: number): boolean;
+/**
+ * The mask the solid ground draws with: the ground window's, and not in the hole (the hole's
+ * edge being the noise threshold). Everywhere with the window and the hole closed.
+ */
+export declare function solidGroundMaskNode(): import("three/webgpu").Node<"bool">;
+/** Whether a fragment is in the hole, a hand's width over: what the pit's floor is drawn in. */
+export declare function groundHoleFloorNode(): any;
+/**
+ * How the solid ground receives shadows while the hole is open: not at all. The storeys that are
+ * hidden above the level shown still cast their shadows (so the rooms stay shaded), and on the
+ * ground that would read as ghosts of a building that is not there.
+ */
+export declare function groundHoleShadowNode(): () => any;
+/**
+ * The ground's colour with a soft shade (`shadeColor`) feathered along the hole's cut and a thin
+ * light line on the cut itself; the plain colour with the hole closed.
+ */
+export declare function groundHoleColorNode(shadeColor: string): import("three/webgpu").Node<"vec3">;
+/**
+ * Feeds the hole the footprints it is cut over (the polygons the grade ring runs along: the level
+ * shown and the ones between it and grade), and says to the rest of the viewer whether the scene
+ * has a level below grade at all (`present`): the ground materials carry the hole's mask, and the
+ * eye's fill light is mounted, from then on, once, so that changing floors only changes uniforms.
+ *
+ * It also stands the pit in the hole (`ground-pit.tsx`): walls cut along the hole's own contour
+ * from the ground (`topAt`, at `topY` flat) down to `floorY`, the floor of the level shown, in the
+ * `topsoil` colour at their top; its dark floor is drawn at `drawnFloorY` (`groundPitFloorY`).
+ */
+export declare function GroundHole({ footprints, present, floorY, drawnFloorY, topY, topAt, topsoil, }: {
+    footprints: ReadonlyArray<ReadonlyArray<Point>>;
+    present: boolean;
+    floorY: number | null;
+    drawnFloorY: number | null;
+    topY: number;
+    topAt: (x: number, z: number) => number;
+    topsoil: string;
+}): import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=ground-hole.d.ts.map

package/dist/site/ground-hole.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-hole.d.ts","sourceRoot":"","sources":["../../src/site/ground-hole.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,oBAAoB,CAAA;AA4B3B;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW,QAA0B,CAAA;AAClD,eAAO,MAAM,UAAU,QAAyB,CAAA;AA8BhD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAU7D;AAED,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAuCtC;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAsD3F;AAED,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAcjE;AAED,qFAAqF;AACrF,wBAAgB,aAAa,IAAI;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAEzF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAOzD;AAKD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAIhE;AAkCD;;;GAGG;AACH,wBAAgB,mBAAmB,wCAElC;AAED,gGAAgG;AAChG,wBAAgB,mBAAmB,QAElC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,CAIhD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,uCAIrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,EACzB,UAAU,EACV,OAAO,EACP,MAAM,EACN,WAAW,EACX,IAAI,EACJ,KAAK,EACL,OAAO,GACR,EAAE;IACD,UAAU,EAAE,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAA;IAC/C,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IACvC,OAAO,EAAE,MAAM,CAAA;CAChB,sCAgDA"}