@pascal-app/nodes 1.0.4 → 1.0.6

package/dist/shared/surface-paint.js

@@ -1,5 +1,5 @@
-import { buildSlotPreviewMaterial, createSlotPaintCapability } from './slot-paint';
-import { swapPreviewMaterial } from './swap-preview-material';
+import { buildSlotPreviewMaterial, createSlotPaintCapability } from './slot-paint.js';
+import { swapPreviewMaterial } from './swap-preview-material.js';
 export const surfacePaintCapability = createSlotPaintCapability({
     resolveRole: () => 'surface',
     applyPreview: ({ material, materialPreset, root }) => {

package/dist/shared/swap-preview-material.d.ts

@@ -1,11 +1,13 @@
-import type { Material, Mesh } from 'three';
+import type { BufferGeometry, Material, Mesh } from 'three';
 /**
  * Shows a paint preview by giving `mesh` another material (or material
- * array), and returns the undo. The undo puts the original back only while the
- * mesh still wears the preview: a commit or rebuild that gave it new materials
- * meanwhile (a new finish adds a palette entry and a geometry group) keeps
- * them — restoring the older, shorter array would leave a group with no
- * material, which the next raycast trips over.
+ * array), and `groups` with it when the preview also regroups the geometry's
+ * triangles onto that array; returns the undo. Groups and materials index into
+ * each other, so the undo only puts back what still is the preview's: groups
+ * a rebuild or commit replaced meanwhile stay, and the original material goes
+ * back only over groups it can draw — restoring an older, shorter array over a
+ * rebuilt geometry's groups would leave a group with no material, which the
+ * next raycast trips over on `material.side`.
  */
-export declare function swapPreviewMaterial(mesh: Mesh, preview: Material | Material[]): () => void;
+export declare function swapPreviewMaterial(mesh: Mesh, preview: Material | Material[], groups?: BufferGeometry['groups']): () => void;
 //# sourceMappingURL=swap-preview-material.d.ts.map

package/dist/shared/swap-preview-material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swap-preview-material.d.ts","sourceRoot":"","sources":["../../src/shared/swap-preview-material.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAE3C;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,GAAG,QAAQ,EAAE,GAAG,MAAM,IAAI,CAM1F"}
+{"version":3,"file":"swap-preview-material.d.ts","sourceRoot":"","sources":["../../src/shared/swap-preview-material.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAE3D;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,QAAQ,GAAG,QAAQ,EAAE,EAC9B,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAChC,MAAM,IAAI,CAcZ"}

package/dist/shared/swap-preview-material.js

@@ -1,16 +1,27 @@
+import { hasMaterialsForGroups } from '@pascal-app/viewer';
 /**
  * Shows a paint preview by giving `mesh` another material (or material
- * array), and returns the undo. The undo puts the original back only while the
- * mesh still wears the preview: a commit or rebuild that gave it new materials
- * meanwhile (a new finish adds a palette entry and a geometry group) keeps
- * them — restoring the older, shorter array would leave a group with no
- * material, which the next raycast trips over.
+ * array), and `groups` with it when the preview also regroups the geometry's
+ * triangles onto that array; returns the undo. Groups and materials index into
+ * each other, so the undo only puts back what still is the preview's: groups
+ * a rebuild or commit replaced meanwhile stay, and the original material goes
+ * back only over groups it can draw — restoring an older, shorter array over a
+ * rebuilt geometry's groups would leave a group with no material, which the
+ * next raycast trips over on `material.side`.
  */
-export function swapPreviewMaterial(mesh, preview) {
+export function swapPreviewMaterial(mesh, preview, groups) {
+    const geometry = mesh.geometry;
     const previous = mesh.material;
+    const previousGroups = geometry.groups;
+    if (groups)
+        geometry.groups = groups;
     mesh.material = preview;
     return () => {
-        if (mesh.material === preview)
+        if (groups && mesh.geometry === geometry && geometry.groups === groups) {
+            geometry.groups = previousGroups;
+        }
+        if (mesh.material === preview && hasMaterialsForGroups(mesh, previous)) {
             mesh.material = previous;
+        }
     };
 }

package/dist/shared/system-check-panel.js

@@ -4,7 +4,7 @@ import { emitter, getLevelElevations, summarizeSystemFor, } from '@pascal-app/co
 import { useViewer } from '@pascal-app/viewer';
 import { AlertTriangle, CheckCircle2, ChevronDown, ChevronRight, Crosshair, ShieldCheck, XCircle, } from 'lucide-react';
 import { useId, useMemo, useState } from 'react';
-import { checkDistributionSystems } from './system-checks';
+import { checkDistributionSystems } from './system-checks.js';
 const CATEGORIES = [
     { id: 'all', label: 'All findings' },
     { id: 'open-end', label: 'Open ends' },

package/dist/shared/system-checks.js

@@ -1,7 +1,7 @@
 import { buildPortComponents, collectSystemPorts, distributionPointToWorld, getWallBaseElevationForNodes, getWallCurveFrameAt, getWallEffectiveHeightForNodes, getWallFaceOffsets, nodeRegistry, validateDwv, } from '@pascal-app/core';
+import { connectionCompatibility } from '@pascal-app/editor/distribution';
 import { Box3, Ray, Vector3 } from 'three';
-import { connectionCompatibility } from './connection-compatibility';
-import { planRunHangerSlots } from './run-hangers';
+import { planRunHangerSlots } from './run-hangers.js';
 export function checkDistributionSystems(nodes) {
     const findings = [...validateDwv(nodes)];
     const ports = collectSystemPorts(nodes);

package/dist/shared/vertical-offset.d.ts

@@ -1,7 +1,7 @@
 import { type AnyNode, type AnyNodeId, DuctSegmentNode, type PortConnection } from '@pascal-app/core';
-import type { DuctFittingNode } from '../duct-fitting/schema';
-import { type DuctProfile } from './auto-fitting';
-import type { ScenePort } from './ports';
+import type { ScenePort } from '@pascal-app/editor/distribution';
+import type { DuctFittingNode } from '../duct-fitting/schema.js';
+import { type DuctProfile } from './auto-fitting.js';
 /**
  * Center-cube vertical-move auto-routing for duct runs.
  *

package/dist/shared/vertical-offset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertical-offset.d.ts","sourceRoot":"","sources":["../../src/shared/vertical-offset.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,eAAe,EACf,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AASrC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAC7C;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB,IAAI,CAAA;AAER,MAAM,MAAM,kBAAkB,GAAG;IAC/B;2EACuE;IACvE,EAAE,EAAE,MAAM,CAAA;IACV;;uCAEmC;IACnC,QAAQ,EAAE,KAAK,EAAE,CAAA;IACjB;;;;yDAIqD;IACrD,UAAU,EAAE,KAAK,EAAE,CAAA;IACnB,oDAAoD;IACpD,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,0CAA0C;IAC1C,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB;8DAC0D;IAC1D,OAAO,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;IACpD,4FAA4F;IAC5F,MAAM,CAAC,EAAE,SAAS,EAAE,CAAA;CACrB,CAAA;AAqoBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,IAAI,EAAE,eAAe,CAAA;IACrB,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,WAAW,CAAA;IACpB,0DAA0D;IAC1D,WAAW,EAAE,cAAc,EAAE,CAAA;IAC7B,2EAA2E;IAC3E,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB;;mBAEe;IACf,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC,GAAG,oBAAoB,CAMvB"}
+{"version":3,"file":"vertical-offset.d.ts","sourceRoot":"","sources":["../../src/shared/vertical-offset.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,eAAe,EACf,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAGhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,gBAAgB,CAAA;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AASrC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAC7C;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB,IAAI,CAAA;AAER,MAAM,MAAM,kBAAkB,GAAG;IAC/B;2EACuE;IACvE,EAAE,EAAE,MAAM,CAAA;IACV;;uCAEmC;IACnC,QAAQ,EAAE,KAAK,EAAE,CAAA;IACjB;;;;yDAIqD;IACrD,UAAU,EAAE,KAAK,EAAE,CAAA;IACnB,oDAAoD;IACpD,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,0CAA0C;IAC1C,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB;8DAC0D;IAC1D,OAAO,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;IACpD,4FAA4F;IAC5F,MAAM,CAAC,EAAE,SAAS,EAAE,CAAA;CACrB,CAAA;AAqoBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,IAAI,EAAE,eAAe,CAAA;IACrB,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,WAAW,CAAA;IACpB,0DAA0D;IAC1D,WAAW,EAAE,cAAc,EAAE,CAAA;IAC7B,2EAA2E;IAC3E,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB;;mBAEe;IACf,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC,GAAG,oBAAoB,CAMvB"}

package/dist/shared/vertical-offset.js

@@ -1,8 +1,8 @@
 import { DuctSegmentNode, } from '@pascal-app/core';
 import { Vector3 } from 'three';
-import { fittingLegLength, getDuctFittingPorts } from '../duct-fitting/ports';
-import { rollToContinueAcrossElbow } from '../duct-segment/geometry';
-import { planElbowAtPort, planElbowRealign, profileDiameterIn, } from './auto-fitting';
+import { fittingLegLength, getDuctFittingPorts } from '../duct-fitting/ports.js';
+import { rollToContinueAcrossElbow } from '../duct-segment/geometry.js';
+import { planElbowAtPort, planElbowRealign, profileDiameterIn, } from './auto-fitting.js';
 /** Joint-coincidence epsilon (m), matching core's port connectivity. */
 const COINCIDENT_EPS_M = 0.05;
 /** Shortest riser worth minting — below this there's no room to offset, so

package/dist/shared/wall-run-move.d.ts

@@ -1,5 +1,5 @@
 import type { AnyNode, GridEvent } from '@pascal-app/core';
-import type { RunWallAttachment } from './distribution-run-contract';
+import type { RunWallAttachment } from '@pascal-app/editor/distribution';
 type Point = [number, number, number];
 export type WallRunMoveResult = {
     path: Point[];

package/dist/shared/wall-run-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-run-move.d.ts","sourceRoot":"","sources":["../../src/shared/wall-run-move.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAEpE,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAErC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,KAAK,EAAE,CAAA;IACb,UAAU,EAAE,iBAAiB,CAAA;CAC9B,CAAA;AAED,oEAAoE;AACpE,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,UAAU,EAAE,iBAAiB,EAC7B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACvC,iBAAiB,CAgBnB;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,UAAU,EAAE,iBAAiB,EAC7B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACxC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,GAAG,sBAAsB,CAAC,GAC5D,iBAAiB,GAAG,IAAI,CAuC1B"}
+{"version":3,"file":"wall-run-move.d.ts","sourceRoot":"","sources":["../../src/shared/wall-run-move.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AAExE,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAErC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,KAAK,EAAE,CAAA;IACb,UAAU,EAAE,iBAAiB,CAAA;CAC9B,CAAA;AAED,oEAAoE;AACpE,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,UAAU,EAAE,iBAAiB,EAC7B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACvC,iBAAiB,CAgBnB;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,UAAU,EAAE,iBAAiB,EAC7B,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACxC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,GAAG,sBAAsB,CAAC,GAC5D,iBAAiB,GAAG,IAAI,CAuC1B"}

package/dist/shelf/definition.d.ts

@@ -1,4 +1,4 @@
 import type { NodeDefinition } from '@pascal-app/core';
-import { ShelfNode } from './schema';
+import { ShelfNode } from './schema.js';
 export declare const shelfDefinition: NodeDefinition<typeof ShelfNode>;
 //# sourceMappingURL=definition.d.ts.map

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;AAUpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA2HpC,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,CA2J5D,CAAA"}

package/dist/shelf/definition.js

@@ -1,13 +1,13 @@
 import { shelfSlots } from '@pascal-app/core';
-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 { 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.js

@@ -1,7 +1,7 @@
 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 { 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/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 })] }));
+}