@pascal-app/nodes 0.1.1

package/dist/shelf/parametrics.js

@@ -0,0 +1,81 @@
+/**
+ * Inspector descriptor for the parametric shelf. Drives both the
+ * auto-derived inspector UI and the AI/MCP `create_shelf` /
+ * `update_shelf` tools with bounded JSON-schema parameters.
+ *
+ * Fields are grouped by intent: Style first (what kind of shelf), then
+ * Topology (rows / columns / back / sides / bottom + wall-shelf bracket
+ * style), then Dimensions. Surface material is paint-tray driven (same
+ * flow as walls / slabs / stairs) and intentionally not surfaced here.
+ */
+export const shelfParametrics = {
+    groups: [
+        {
+            label: 'Style',
+            fields: [
+                {
+                    key: 'style',
+                    kind: 'enum',
+                    options: ['wall-shelf', 'bookshelf', 'open-rack', 'cubby'],
+                },
+            ],
+        },
+        {
+            label: 'Topology',
+            fields: [
+                { key: 'rows', kind: 'number', min: 1, max: 8, step: 1 },
+                // Columns only meaningful for kinds with vertical dividers.
+                {
+                    key: 'columns',
+                    kind: 'number',
+                    min: 1,
+                    max: 6,
+                    step: 1,
+                    visibleIf: (n) => n.style === 'bookshelf' || n.style === 'cubby',
+                },
+                // Sides toggle only applies to bookshelf (cubby always on, the
+                // others use their own post structure).
+                {
+                    key: 'withSides',
+                    kind: 'boolean',
+                    visibleIf: (n) => n.style === 'bookshelf',
+                },
+                // Back toggle only applies to bookshelf and open-rack (cubby
+                // always has a back, wall-shelf has no back).
+                {
+                    key: 'withBack',
+                    kind: 'boolean',
+                    visibleIf: (n) => n.style === 'bookshelf' || n.style === 'open-rack',
+                },
+                // Bottom toggle only applies to bookshelf and cubby — closes
+                // the lowest cell with a floor board so items can host there.
+                {
+                    key: 'withBottom',
+                    kind: 'boolean',
+                    visibleIf: (n) => n.style === 'bookshelf' || n.style === 'cubby',
+                },
+                // Bracket style only matters for wall-shelf — the other styles
+                // structure themselves through sides / posts / dividers.
+                {
+                    key: 'bracketStyle',
+                    kind: 'enum',
+                    options: ['minimal', 'industrial', 'hidden'],
+                    visibleIf: (n) => n.style === 'wall-shelf',
+                },
+            ],
+        },
+        {
+            label: 'Dimensions',
+            fields: [
+                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 3.0, step: 0.05 },
+                { key: 'depth', kind: 'number', unit: 'm', min: 0.1, max: 1.0, step: 0.05 },
+                { key: 'thickness', kind: 'number', unit: 'm', min: 0.01, max: 0.1, step: 0.005 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.05, max: 2.5, step: 0.05 },
+            ],
+        },
+        {
+            label: 'Position',
+            fields: [{ key: 'position', kind: 'vec3' }],
+        },
+    ],
+};

package/dist/shelf/preview.d.ts

@@ -0,0 +1,31 @@
+import type { ShelfNode } from './schema';
+/**
+ * Translucent preview of a shelf — used by the placement tool's cursor
+ * and the registry mover. Defers to `buildShelfGeometry` so the preview
+ * shape stays in lockstep with whatever the actual shelf will render,
+ * then walks the result, **clones** each mesh's material, and mutates
+ * the clone for a translucent ghost.
+ *
+ * Cloning is non-negotiable: shelf geometry may receive materials from
+ * shared viewer caches, so mutating `mat.transparent = true` here would
+ * leak into committed shelves using the same material.
+ *
+ * Building the full geometry tree per-frame would be wasteful, so we
+ * memoize the group + dispose the per-mesh material clones on unmount.
+ * Geometry is intentionally NOT disposed — `buildShelfGeometry` creates
+ * fresh BufferGeometry per call, but if a future revision returns
+ * cached geometry, disposing here would corrupt later renders. Keep the
+ * cleanup focused on what the preview itself created (the clones).
+ *
+ * **Raycast is disabled** on every preview mesh: the cursor follows the
+ * shelf, so without this the preview itself would intercept the cursor
+ * ray, `grid:move` would stop firing as soon as the preview entered the
+ * cursor cone, and the placement tool would lose track of the cursor's
+ * grid position. Disabling raycast lets the ray pass through the ghost
+ * to the grid plane below.
+ */
+declare const ShelfPreview: ({ node }: {
+    node: ShelfNode;
+}) => import("react").JSX.Element;
+export default ShelfPreview;
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +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"}

package/dist/shelf/preview.js

@@ -0,0 +1,77 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo } from 'react';
+import { buildShelfGeometry } from './geometry';
+/**
+ * Translucent preview of a shelf — used by the placement tool's cursor
+ * and the registry mover. Defers to `buildShelfGeometry` so the preview
+ * shape stays in lockstep with whatever the actual shelf will render,
+ * then walks the result, **clones** each mesh's material, and mutates
+ * the clone for a translucent ghost.
+ *
+ * Cloning is non-negotiable: shelf geometry may receive materials from
+ * shared viewer caches, so mutating `mat.transparent = true` here would
+ * leak into committed shelves using the same material.
+ *
+ * Building the full geometry tree per-frame would be wasteful, so we
+ * memoize the group + dispose the per-mesh material clones on unmount.
+ * Geometry is intentionally NOT disposed — `buildShelfGeometry` creates
+ * fresh BufferGeometry per call, but if a future revision returns
+ * cached geometry, disposing here would corrupt later renders. Keep the
+ * cleanup focused on what the preview itself created (the clones).
+ *
+ * **Raycast is disabled** on every preview mesh: the cursor follows the
+ * shelf, so without this the preview itself would intercept the cursor
+ * ray, `grid:move` would stop firing as soon as the preview entered the
+ * cursor cone, and the placement tool would lose track of the cursor's
+ * grid position. Disabling raycast lets the ray pass through the ghost
+ * to the grid plane below.
+ */
+const ShelfPreview = ({ node }) => {
+    const shading = useViewer((s) => s.shading);
+    const built = useMemo(() => buildShelfGeometry(node, undefined, shading), [node, shading]);
+    useEffect(() => {
+        const cloned = [];
+        built.traverse((obj) => {
+            // Skip pointer events: see component-level note above.
+            ;
+            obj.raycast = () => { };
+            // `Mesh.material` is typed as `Material | Material[]` upstream;
+            // every shelf board carries a material from the geometry builder.
+            // Access through a structural cast keeps the assignment well-typed
+            // without depending on the Mesh union.
+            const mesh = obj;
+            if (!mesh.material)
+                return;
+            const cloneAndSwap = (mat) => {
+                const c = mat.clone();
+                c.transparent = true;
+                c.opacity = 0.5;
+                c.depthWrite = false;
+                cloned.push(c);
+                return c;
+            };
+            if (Array.isArray(mesh.material)) {
+                mesh.material = mesh.material.map(cloneAndSwap);
+            }
+            else {
+                mesh.material = cloneAndSwap(mesh.material);
+            }
+        });
+        return () => {
+            // Dispose only the clones we made — never the shared cached
+            // material returned by the builder, which other shelves in the
+            // scene may still reference. Geometry is left alone for the same
+            // reason; the builder may move to a cached strategy in future.
+            for (const c of cloned)
+                c.dispose();
+            built.traverse((obj) => {
+                const mesh = obj;
+                mesh.geometry?.dispose();
+            });
+        };
+    }, [built]);
+    return _jsx("primitive", { object: built });
+};
+export default ShelfPreview;

package/dist/shelf/schema.d.ts

@@ -0,0 +1,2 @@
+export { ShelfNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/shelf/schema.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/shelf/schema.js

@@ -0,0 +1,6 @@
+// Shelf schema lives in core for now (referenced by the hand-maintained
+// AnyNode union). Phase 6 derives AnyNode from the registry and the schema
+// moves entirely into this package. Re-exporting here keeps all shelf-related
+// imports inside @pascal-app/nodes/shelf — node bundle consumers don't need
+// to know which side of the migration owns the file.
+export { ShelfNode } from '@pascal-app/core';

package/dist/shelf/slots.d.ts

@@ -0,0 +1,9 @@
+import type { SlotDeclaration } from '@pascal-app/core';
+import type { ShelfNode } from './schema';
+export type ShelfSlotId = 'shelves' | 'frame' | 'back';
+export declare const SHELF_SLOT_DEFAULT_COLOR = "#ffffff";
+/** Map a builder mesh name to its slot id (null = not a paintable shelf part). */
+export declare function shelfSlotIdForMeshName(name: string): ShelfSlotId | null;
+/** Which slots a given shelf actually exposes (depends on style/flags). */
+export declare function shelfSlots(node: ShelfNode): SlotDeclaration[];
+//# sourceMappingURL=slots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/shelf/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAA;AAGtD,eAAO,MAAM,wBAAwB,YAAY,CAAA;AAEjD,kFAAkF;AAClF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAavE;AAED,2EAA2E;AAC3E,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,EAAE,CAS7D"}

package/dist/shelf/slots.js

@@ -0,0 +1,30 @@
+// Visual parity with the retired DEFAULT_SHELF_MATERIAL (off-white).
+export const SHELF_SLOT_DEFAULT_COLOR = '#ffffff';
+/** Map a builder mesh name to its slot id (null = not a paintable shelf part). */
+export function shelfSlotIdForMeshName(name) {
+    if (name.startsWith('shelf-board'))
+        return 'shelves';
+    if (name === 'shelf-back')
+        return 'back';
+    if (name.startsWith('shelf-side') ||
+        name.startsWith('shelf-post') ||
+        name.startsWith('shelf-divider') ||
+        name.startsWith('shelf-bracket') ||
+        name.startsWith('shelf-brace')) {
+        return 'frame';
+    }
+    return null;
+}
+/** Which slots a given shelf actually exposes (depends on style/flags). */
+export function shelfSlots(node) {
+    const slots = [
+        { slotId: 'shelves', label: 'Shelves', default: SHELF_SLOT_DEFAULT_COLOR },
+    ];
+    const hasFrame = !(node.style === 'wall-shelf' && node.bracketStyle === 'hidden');
+    if (hasFrame)
+        slots.push({ slotId: 'frame', label: 'Frame', default: SHELF_SLOT_DEFAULT_COLOR });
+    const hasBack = node.style === 'cubby' || (node.style === 'bookshelf' && node.withBack);
+    if (hasBack)
+        slots.push({ slotId: 'back', label: 'Back', default: SHELF_SLOT_DEFAULT_COLOR });
+    return slots;
+}

package/dist/shelf/tool.d.ts

@@ -0,0 +1,3 @@
+declare const ShelfTool: () => import("react").JSX.Element | null;
+export default ShelfTool;
+//# sourceMappingURL=tool.d.ts.map

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

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

package/dist/shelf/tool.js

@@ -0,0 +1,125 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { collectAlignmentAnchors, emitter, ShelfNode, useScene, } from '@pascal-app/core';
+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';
+const ShelfTool = () => {
+    const activeLevelId = useViewer((state) => state.selection.levelId);
+    const cursorRef = useRef(null);
+    const previousSnapRef = useRef(null);
+    const cursorVisibleRef = useRef(false);
+    const [cursorVisible, setCursorVisible] = useState(false);
+    // Default-shaped shelf for the placement preview. Pulls from
+    // `shelfDefinition.defaults()` so the preview matches what the commit
+    // will actually create (a 1m × 0.5m × 1.8m cubby 3x2 with closed back
+    // + bottom). The schema-level defaults are deliberately the v1
+    // wall-shelf — those exist so v1 scenes loading under v2 keep their
+    // original visual; the placement default is a separate, user-facing
+    // choice that lives on the definition.
+    const previewNode = useMemo(() => ShelfNode.parse({
+        ...shelfDefinition.defaults(),
+        name: 'Shelf',
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+    }), []);
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        previousSnapRef.current = null;
+        cursorVisibleRef.current = false;
+        setCursorVisible(false);
+        /**
+         * Snapped cursor position from the latest `grid:move`. Used as the
+         * commit position for ANY click variant (grid or node), so clicks
+         * on vertical surfaces (other shelves, walls, etc.) still commit
+         * where the user was visually targeting.
+         */
+        const lastCursorRef = { current: null };
+        // Alignment candidates — anchors of every OTHER alignable object (items,
+        // walls, fences, slabs, ceilings, columns, other shelves). Gathered once
+        // here and refreshed after each placement so a just-placed shelf becomes a
+        // target for the next one. `previewNode.id` never collides with a scene
+        // node, so nothing real is excluded.
+        let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
+        const onGridMove = (event) => {
+            if (!cursorVisibleRef.current) {
+                cursorVisibleRef.current = true;
+                setCursorVisible(true);
+            }
+            const { position, guides } = resolveAlignedFloorPlacement({
+                node: previewNode,
+                rawX: event.localPosition[0],
+                rawZ: event.localPosition[2],
+                gridStep: useEditor.getState().gridSnapStep,
+                candidates: alignmentCandidates,
+                showAlignment: isAlignmentGuideActive(),
+                applyAlignmentSnap: isMagneticSnapActive(),
+                bypassGrid: !isGridSnapActive(),
+            });
+            useAlignmentGuides.getState().set(guides);
+            const visualPosition = getFloorStackPreviewPosition({
+                node: previewNode,
+                position,
+                rotation: previewNode.rotation,
+                levelId: activeLevelId,
+            });
+            cursorRef.current?.position.set(...visualPosition);
+            lastCursorRef.current = position;
+            const nextSnapKey = movementSfxStepKey({
+                coords: [position[0], position[2]],
+                gridSnapActive: isGridSnapActive(),
+                gridStep: useEditor.getState().gridSnapStep,
+            });
+            const prev = previousSnapRef.current;
+            if (prev !== nextSnapKey) {
+                triggerSFX('sfx:grid-snap');
+                previousSnapRef.current = nextSnapKey;
+            }
+        };
+        const commitAtCursor = (event) => {
+            // Prefer the latest `grid:move` cursor snapshot; fall back to
+            // projecting the click event into level-local coords if no
+            // grid:move has fired yet (e.g. cursor entered via a node hit
+            // first). Both paths apply the same grid snap.
+            const position = lastCursorRef.current ??
+                getLevelLocalSnappedPosition(activeLevelId, event, useEditor.getState().gridSnapStep, !isGridSnapActive());
+            const shelf = ShelfNode.parse({
+                ...shelfDefinition.defaults(),
+                name: 'Shelf',
+                position,
+                rotation: [0, 0, 0],
+            });
+            useScene.getState().createNode(shelf, activeLevelId);
+            useViewer.getState().setSelection({ selectedIds: [shelf.id] });
+            triggerSFX('sfx:item-place');
+            useAlignmentGuides.getState().clear();
+            if (useEditor.getState().getContinuation('point') === 'repeat') {
+                // The placed shelf is now a valid alignment target for the next one.
+                alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
+            }
+            else {
+                cursorVisibleRef.current = false;
+                setCursorVisible(false);
+                useEditor.getState().setTool(null);
+            }
+            stopPlacementCommitPropagation(event);
+        };
+        emitter.on('grid:move', onGridMove);
+        const unsubscribePlacementClicks = subscribeFloorPlacementClicks(commitAtCursor);
+        return () => {
+            emitter.off('grid:move', onGridMove);
+            unsubscribePlacementClicks();
+            // Drop any alignment guide left over when the tool deactivates (kind
+            // switch, Esc, unmount) so it doesn't linger over the canvas.
+            useAlignmentGuides.getState().clear();
+        };
+    }, [activeLevelId, previewNode]);
+    if (!activeLevelId)
+        return null;
+    return (_jsx("group", { ref: cursorRef, visible: cursorVisible, children: _jsx(ShelfPreview, { node: previewNode }) }));
+};
+export default ShelfTool;

package/dist/site/definition.d.ts

@@ -0,0 +1,10 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { SiteNode } from './schema';
+/**
+ * Site — Stage A. Top-level container under the scene root; holds
+ * buildings + property-line polygon + zones. No system (sites don't
+ * have per-frame work). Not movable / deletable — they're the scene
+ * root.
+ */
+export declare const siteDefinition: NodeDefinition<typeof SiteNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +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"}

package/dist/site/definition.js

@@ -0,0 +1,54 @@
+import { SiteNode as SiteNodeSchema } from '@pascal-app/core';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
+import { siteParametrics } from './parametrics';
+import { SiteNode } from './schema';
+/**
+ * Site — Stage A. Top-level container under the scene root; holds
+ * buildings + property-line polygon + zones. No system (sites don't
+ * have per-frame work). Not movable / deletable — they're the scene
+ * root.
+ */
+export const siteDefinition = {
+    kind: 'site',
+    schemaVersion: 1,
+    schema: SiteNode,
+    category: 'site',
+    defaults: () => {
+        const stub = SiteNodeSchema.parse({ id: 'site_default', type: 'site' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        // 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`.
+        duplicable: false,
+        deletable: false,
+        presettable: false,
+    },
+    parametrics: siteParametrics,
+    measurement: {
+        features: (node) => polygonMeasurementFeatures({
+            featurePrefix: 'site',
+            height: 0,
+            label: 'Property',
+            polygon: node.polygon.points,
+        }),
+    },
+    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
+    dirtyTracking: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    presentation: {
+        label: 'Site',
+        description: 'The top-level container holding buildings, zones, and the property boundary.',
+        icon: { kind: 'url', src: '/icons/site-flag.webp' },
+        paletteSection: 'site',
+        paletteOrder: 5,
+    },
+    mcp: {
+        description: 'Top-level site container.',
+    },
+};

package/dist/site/index.d.ts

@@ -0,0 +1,2 @@
+export { siteDefinition } from './definition';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/site/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}

package/dist/site/index.js

@@ -0,0 +1 @@
+export { siteDefinition } from './definition';

package/dist/site/parametrics.d.ts

@@ -0,0 +1,3 @@
+import type { ParametricDescriptor, SiteNode } from '@pascal-app/core';
+export declare const siteParametrics: ParametricDescriptor<SiteNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +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"}

package/dist/site/parametrics.js

@@ -0,0 +1,3 @@
+export const siteParametrics = {
+    groups: [],
+};

package/dist/site/recessed-slab-ground-holes.d.ts

@@ -0,0 +1,3 @@
+import { type AnyNode } from '@pascal-app/core';
+export declare function getRecessedSlabGroundHoles(nodes: Record<string, AnyNode>): Array<Array<[number, number]>>;
+//# sourceMappingURL=recessed-slab-ground-holes.d.ts.map

package/dist/site/recessed-slab-ground-holes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recessed-slab-ground-holes.d.ts","sourceRoot":"","sources":["../../src/site/recessed-slab-ground-holes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CA8ChC"}

package/dist/site/recessed-slab-ground-holes.js

@@ -0,0 +1,46 @@
+import { getRenderableSlabPolygon, } from '@pascal-app/core';
+export function getRecessedSlabGroundHoles(nodes) {
+    const nodeList = Object.values(nodes);
+    const levelIndexById = new Map();
+    const wallsByLevel = new Map();
+    const slabsByLevel = new Map();
+    let lowestLevelIndex = Number.POSITIVE_INFINITY;
+    const pushByLevel = (map, levelId, node) => {
+        const entries = map.get(levelId);
+        if (entries)
+            entries.push(node);
+        else
+            map.set(levelId, [node]);
+    };
+    for (const node of nodeList) {
+        if (node.type === 'level') {
+            levelIndexById.set(node.id, node.level);
+            lowestLevelIndex = Math.min(lowestLevelIndex, node.level);
+            continue;
+        }
+        const levelId = node.parentId ?? null;
+        if (node.type === 'wall')
+            pushByLevel(wallsByLevel, levelId, node);
+        else if (node.type === 'slab')
+            pushByLevel(slabsByLevel, levelId, node);
+    }
+    return nodeList
+        .filter((node) => node.type === 'slab' &&
+        node.visible &&
+        node.polygon.length >= 3 &&
+        (node.elevation ?? 0.05) < 0)
+        .filter((slab) => {
+        if (!Number.isFinite(lowestLevelIndex))
+            return true;
+        const parentLevel = slab.parentId ? levelIndexById.get(slab.parentId) : undefined;
+        return parentLevel === lowestLevelIndex;
+    })
+        .map((slab) => {
+        const levelId = slab.parentId ?? null;
+        const context = {
+            walls: wallsByLevel.get(levelId) ?? [],
+            siblingSlabs: (slabsByLevel.get(levelId) ?? []).filter((sibling) => sibling.id !== slab.id),
+        };
+        return getRenderableSlabPolygon(slab, context);
+    });
+}

package/dist/site/renderer.d.ts

@@ -0,0 +1,6 @@
+import { type SiteNode } from '@pascal-app/core';
+export declare const SiteRenderer: ({ node }: {
+    node: SiteNode;
+}) => import("react").JSX.Element | null;
+export default SiteRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/site/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AAkGzB,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,uCAoMxD,CAAA;AAED,eAAe,YAAY,CAAA"}