@pascal-app/viewer 0.1.13 → 0.2.0

package/dist/components/renderers/ceiling/ceiling-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ceiling-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/ceiling/ceiling-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,kBAAkB,CAAA;AAuChE,eAAO,MAAM,eAAe,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,4CAe9D,CAAA"}
+{"version":3,"file":"ceiling-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/ceiling/ceiling-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,kBAAkB,CAAA;AA+ChE,eAAO,MAAM,eAAe,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,4CAwB9D,CAAA"}

package/dist/components/renderers/ceiling/ceiling-renderer.js

@@ -1,18 +1,25 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRegistry } from '@pascal-app/core';
 import { useRef } from 'react';
-import { faceDirection, float, mix, positionWorld, smoothstep } from 'three/tsl';
-import { DoubleSide, MeshBasicNodeMaterial } from 'three/webgpu';
+import { float, mix, positionWorld, smoothstep } from 'three/tsl';
+import { BackSide, FrontSide, MeshBasicNodeMaterial } from 'three/webgpu';
 import { useNodeEvents } from '../../../hooks/use-node-events';
 import { NodeRenderer } from '../node-renderer';
 // TSL material that renders differently based on face direction:
 // - Back face (looking up at ceiling from below): solid
 // - Front face (looking down at ceiling from above): 30% opacity
-const ceilingMaterial = new MeshBasicNodeMaterial({
-    color: 0x999999,
-    side: DoubleSide,
+const ceilingTopMaterial = new MeshBasicNodeMaterial({
+    color: 0xb5_a7_8d,
     transparent: true,
     depthWrite: false,
+    side: FrontSide,
+    // Disabled as we only show ceiling grid when needed
+    // alphaTestNode: float(0.4), // Discard pixels with alpha below 0.4 to create grid lines and not affect depth buffer
+});
+const ceilingBottomMaterial = new MeshBasicNodeMaterial({
+    color: 0x99_99_99,
+    transparent: true,
+    side: BackSide,
 });
 // Create grid pattern based on local position
 const gridScale = 5; // Grid cells per meter (1 = 1m grid)
@@ -25,14 +32,14 @@ const lineX = smoothstep(lineWidth, 0, gridX).add(smoothstep(1.0 - lineWidth, 1.
 const lineY = smoothstep(lineWidth, 0, gridY).add(smoothstep(1.0 - lineWidth, 1.0, gridY));
 // Combine: if either X or Y is a line, show the line
 const gridPattern = lineX.max(lineY);
-// Grid lines at 0.8 opacity, spaces at 0.1 opacity
-const gridOpacity = mix(float(0.1), float(0.8), gridPattern);
+// Grid lines at 0.6 opacity, spaces at 0.2 opacity
+const gridOpacity = mix(float(0.2), float(0.6), gridPattern);
 // faceDirection is 1.0 for front face, -1.0 for back face
 // Front face (top, looking down): grid pattern, Back face (bottom, looking up): solid
-ceilingMaterial.opacityNode = mix(float(1.0), gridOpacity, faceDirection.greaterThan(0.0));
+ceilingTopMaterial.opacityNode = gridOpacity;
 export const CeilingRenderer = ({ node }) => {
     const ref = useRef(null);
     useRegistry(node.id, 'ceiling', ref);
     const handlers = useNodeEvents(node, 'ceiling');
-    return (_jsxs("mesh", { ref: ref, material: ceilingMaterial, ...handlers, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] }));
+    return (_jsxs("mesh", { material: ceilingBottomMaterial, ref: ref, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("mesh", { material: ceilingTopMaterial, name: "ceiling-grid", ...handlers, scale: 0, visible: false, children: _jsx("boxGeometry", { args: [0, 0, 0] }) }), node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] }));
 };

package/dist/components/renderers/door/door-renderer.d.ts

@@ -0,0 +1,5 @@
+import { type DoorNode } from '@pascal-app/core';
+export declare const DoorRenderer: ({ node }: {
+    node: DoorNode;
+}) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=door-renderer.d.ts.map

package/dist/components/renderers/door/door-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/door/door-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,kBAAkB,CAAA;AAK7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,4CAsBxD,CAAA"}

package/dist/components/renderers/door/door-renderer.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRegistry } from '@pascal-app/core';
+import { useRef } from 'react';
+import { useNodeEvents } from '../../../hooks/use-node-events';
+export const DoorRenderer = ({ node }) => {
+    const ref = useRef(null);
+    useRegistry(node.id, 'door', ref);
+    const handlers = useNodeEvents(node, 'door');
+    const isTransient = !!node.metadata?.isTransient;
+    return (_jsxs("mesh", { castShadow: true, position: node.position, receiveShadow: true, ref: ref, rotation: node.rotation, visible: node.visible, ...(isTransient ? {} : handlers), children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("meshStandardMaterial", { color: "#d1d5db" })] }));
+};

package/dist/components/renderers/guide/guide-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"guide-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/guide/guide-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,kBAAkB,CAAA;AAQ9D,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,4CAe1D,CAAA"}
+{"version":3,"file":"guide-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/guide/guide-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,kBAAkB,CAAA;AAS9D,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,4CAqB1D,CAAA"}

package/dist/components/renderers/guide/guide-renderer.js

@@ -6,11 +6,13 @@ import { DoubleSide, TextureLoader } from 'three';
 import { float, texture } from 'three/tsl';
 import { MeshBasicNodeMaterial } from 'three/webgpu';
 import { useAssetUrl } from '../../../hooks/use-asset-url';
+import useViewer from '../../../store/use-viewer';
 export const GuideRenderer = ({ node }) => {
+    const showGuides = useViewer((s) => s.showGuides);
     const ref = useRef(null);
     useRegistry(node.id, 'guide', ref);
     const resolvedUrl = useAssetUrl(node.url);
-    return (_jsx("group", { ref: ref, position: node.position, rotation: [0, node.rotation[1], 0], children: resolvedUrl && (_jsx(Suspense, { children: _jsx(GuidePlane, { url: resolvedUrl, scale: node.scale, opacity: node.opacity }) })) }));
+    return (_jsx("group", { position: node.position, ref: ref, rotation: [0, node.rotation[1], 0], visible: showGuides, children: resolvedUrl && (_jsx(Suspense, { children: _jsx(GuidePlane, { opacity: node.opacity, scale: node.scale, url: resolvedUrl }) })) }));
 };
 const GuidePlane = ({ url, scale, opacity }) => {
     const tex = useLoader(TextureLoader, url);
@@ -32,5 +34,5 @@ const GuidePlane = ({ url, scale, opacity }) => {
         });
         return { width: planeWidth, height: planeHeight, material: mat };
     }, [tex, scale, opacity]);
-    return (_jsx("mesh", { rotation: [-Math.PI / 2, 0, 0], material: material, raycast: () => { }, frustumCulled: false, children: _jsx("planeGeometry", { args: [width, height], boundingBox: null, boundingSphere: null }) }));
+    return (_jsx("mesh", { frustumCulled: false, material: material, raycast: () => { }, rotation: [-Math.PI / 2, 0, 0], children: _jsx("planeGeometry", { args: [width, height], boundingBox: null, boundingSphere: null }) }));
 };

package/dist/components/renderers/item/item-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"item-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/item/item-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,QAAQ,EAAyB,MAAM,kBAAkB,CAAA;AAoCvF,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,4CAexD,CAAA"}
+{"version":3,"file":"item-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/item/item-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAwCzB,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,4CAexD,CAAA"}

package/dist/components/renderers/item/item-renderer.js

@@ -1,16 +1,20 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRegistry, useScene } from '@pascal-app/core';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useInteractive, useRegistry, useScene, } from '@pascal-app/core';
+import { useAnimations } from '@react-three/drei';
 import { Clone } from '@react-three/drei/core/Clone';
 import { useGLTF } from '@react-three/drei/core/Gltf';
+import { useFrame } from '@react-three/fiber';
 import { Suspense, useEffect, useMemo, useRef } from 'react';
+import { MathUtils } from 'three';
 import { positionLocal, smoothstep, time } from 'three/tsl';
 import { DoubleSide, MeshStandardNodeMaterial } from 'three/webgpu';
 import { useNodeEvents } from '../../../hooks/use-node-events';
 import { resolveCdnUrl } from '../../../lib/asset-url';
+import { useItemLightPool } from '../../../store/use-item-light-pool';
 import { NodeRenderer } from '../node-renderer';
 // Shared materials to avoid creating new instances for every mesh
 const defaultMaterial = new MeshStandardNodeMaterial({
-    color: 0xffffff,
+    color: 0xff_ff_ff,
     roughness: 1,
     metalness: 0,
 });
@@ -33,7 +37,7 @@ const getMaterialForOriginal = (original) => {
 export const ItemRenderer = ({ node }) => {
     const ref = useRef(null);
     useRegistry(node.id, node.type, ref);
-    return (_jsxs("group", { position: node.position, rotation: node.rotation, ref: ref, visible: node.visible, children: [_jsx(Suspense, { fallback: _jsx(PreviewModel, { node: node }), children: _jsx(ModelRenderer, { node: node }) }), node.children?.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] }));
+    return (_jsxs("group", { position: node.position, ref: ref, rotation: node.rotation, visible: node.visible, children: [_jsx(Suspense, { fallback: _jsx(PreviewModel, { node: node }), children: _jsx(ModelRenderer, { node: node }) }), node.children?.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] }));
 };
 const previewMaterial = new MeshStandardNodeMaterial({
     color: '#cccccc',
@@ -45,10 +49,15 @@ const previewOpacity = smoothstep(0.42, 0.55, positionLocal.y.add(time.mul(-0.2)
 previewMaterial.opacityNode = previewOpacity;
 previewMaterial.transparent = true;
 const PreviewModel = ({ node }) => {
-    return (_jsx("mesh", { "position-y": node.asset.dimensions[1] / 2, material: previewMaterial, children: _jsx("boxGeometry", { args: [node.asset.dimensions[0], node.asset.dimensions[1], node.asset.dimensions[2]] }) }));
+    return (_jsx("mesh", { material: previewMaterial, "position-y": node.asset.dimensions[1] / 2, children: _jsx("boxGeometry", { args: [node.asset.dimensions[0], node.asset.dimensions[1], node.asset.dimensions[2]] }) }));
 };
+const multiplyScales = (a, b) => [a[0] * b[0], a[1] * b[1], a[2] * b[2]];
 const ModelRenderer = ({ node }) => {
-    const { scene, nodes } = useGLTF(resolveCdnUrl(node.asset.src) || '');
+    const { scene, nodes, animations } = useGLTF(resolveCdnUrl(node.asset.src) || '');
+    const ref = useRef(null);
+    const { actions } = useAnimations(animations, ref);
+    // Freeze the interactive definition at mount — asset schemas don't change at runtime
+    const interactiveRef = useRef(node.asset.interactive);
     if (nodes.cutout) {
         nodes.cutout.visible = false;
     }
@@ -58,6 +67,13 @@ const ModelRenderer = ({ node }) => {
             return;
         useScene.getState().dirtyNodes.add(node.parentId);
     }, [node.parentId]);
+    useEffect(() => {
+        const interactive = interactiveRef.current;
+        if (!interactive)
+            return;
+        useInteractive.getState().initItem(node.id, interactive);
+        return () => useInteractive.getState().removeItem(node.id);
+    }, [node.id]);
     useMemo(() => {
         scene.traverse((child) => {
             if (child.isMesh) {
@@ -81,5 +97,74 @@ const ModelRenderer = ({ node }) => {
             }
         });
     }, [scene]);
-    return (_jsx(Clone, { object: scene, scale: node.asset.scale, position: node.asset.offset, rotation: node.asset.rotation, ...handlers }));
+    const interactive = interactiveRef.current;
+    const animEffect = interactive?.effects.find((e) => e.kind === 'animation') ?? null;
+    const lightEffects = interactive?.effects.filter((e) => e.kind === 'light') ?? [];
+    return (_jsxs(_Fragment, { children: [_jsx(Clone, { object: scene, position: node.asset.offset, ref: ref, rotation: node.asset.rotation, scale: multiplyScales(node.asset.scale || [1, 1, 1], node.scale || [1, 1, 1]), ...handlers }), animations.length > 0 && (_jsx(ItemAnimation, { actions: actions, animations: animations, animEffect: animEffect, interactive: interactive ?? null, nodeId: node.id })), lightEffects.map((effect, i) => (_jsx(ItemLightRegistrar, { effect: effect, index: i, interactive: interactive, nodeId: node.id }, i)))] }));
+};
+const ItemAnimation = ({ nodeId, animEffect, interactive, actions, animations, }) => {
+    const activeClipRef = useRef(null);
+    const fadingOutRef = useRef(null);
+    // Reactive: derive target clip name — only re-renders when the clip name itself changes
+    const targetClip = useInteractive((s) => {
+        const values = s.items[nodeId]?.controlValues;
+        if (!animEffect)
+            return animations[0]?.name ?? null;
+        const toggleIndex = interactive.controls.findIndex((c) => c.kind === 'toggle');
+        const isOn = toggleIndex >= 0 ? Boolean(values?.[toggleIndex]) : false;
+        return isOn
+            ? (animEffect.clips.on ?? null)
+            : (animEffect.clips.off ?? animEffect.clips.loop ?? null);
+    });
+    // When target clip changes: kick off the transition
+    useEffect(() => {
+        // Cancel any ongoing fade-out immediately
+        if (fadingOutRef.current) {
+            fadingOutRef.current.timeScale = 0;
+            fadingOutRef.current = null;
+        }
+        // Move current clip to fade-out
+        if (activeClipRef.current && activeClipRef.current !== targetClip) {
+            const old = actions[activeClipRef.current];
+            if (old?.isRunning())
+                fadingOutRef.current = old;
+        }
+        // Start new clip at timeScale 0.01 (as 0 would cause isRunning to be false and thus not play at all), then fade in to 1
+        activeClipRef.current = targetClip;
+        if (targetClip) {
+            const next = actions[targetClip];
+            if (next) {
+                next.timeScale = 0.01;
+                next.play();
+            }
+        }
+    }, [targetClip, actions]);
+    // useFrame: only lerping — no logic
+    useFrame((_, delta) => {
+        if (fadingOutRef.current) {
+            const action = fadingOutRef.current;
+            action.timeScale = MathUtils.lerp(action.timeScale, 0, Math.min(delta * 5, 1));
+            if (action.timeScale < 0.01) {
+                action.timeScale = 0;
+                fadingOutRef.current = null;
+            }
+        }
+        if (activeClipRef.current) {
+            const action = actions[activeClipRef.current];
+            if (action?.isRunning() && action.timeScale < 1) {
+                action.timeScale = MathUtils.lerp(action.timeScale, 1, Math.min(delta * 5, 1));
+                if (1 - action.timeScale < 0.01)
+                    action.timeScale = 1;
+            }
+        }
+    });
+    return null;
+};
+const ItemLightRegistrar = ({ nodeId, effect, interactive, index, }) => {
+    useEffect(() => {
+        const key = `${nodeId}:${index}`;
+        useItemLightPool.getState().register(key, nodeId, effect, interactive);
+        return () => useItemLightPool.getState().unregister(key);
+    }, [nodeId, index, effect, interactive]);
+    return null;
 };

package/dist/components/renderers/node-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-renderer.d.ts","sourceRoot":"","sources":["../../../src/components/renderers/node-renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAAY,MAAM,kBAAkB,CAAA;AAczD,eAAO,MAAM,YAAY,GAAI,YAAY;IAAE,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,mDAqBjE,CAAA"}
+{"version":3,"file":"node-renderer.d.ts","sourceRoot":"","sources":["../../../src/components/renderers/node-renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAAY,MAAM,kBAAkB,CAAA;AAgBzD,eAAO,MAAM,YAAY,GAAI,YAAY;IAAE,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,mDAuBjE,CAAA"}

package/dist/components/renderers/node-renderer.js

@@ -3,10 +3,12 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { useScene } from '@pascal-app/core';
 import { BuildingRenderer } from './building/building-renderer';
 import { CeilingRenderer } from './ceiling/ceiling-renderer';
+import { DoorRenderer } from './door/door-renderer';
 import { GuideRenderer } from './guide/guide-renderer';
 import { ItemRenderer } from './item/item-renderer';
 import { LevelRenderer } from './level/level-renderer';
 import { RoofRenderer } from './roof/roof-renderer';
+import { RoofSegmentRenderer } from './roof-segment/roof-segment-renderer';
 import { ScanRenderer } from './scan/scan-renderer';
 import { SiteRenderer } from './site/site-renderer';
 import { SlabRenderer } from './slab/slab-renderer';
@@ -17,5 +19,5 @@ export const NodeRenderer = ({ nodeId }) => {
     const node = useScene((state) => state.nodes[nodeId]);
     if (!node)
         return null;
-    return (_jsxs(_Fragment, { children: [node.type === 'site' && _jsx(SiteRenderer, { node: node }), node.type === 'building' && _jsx(BuildingRenderer, { node: node }), node.type === 'ceiling' && _jsx(CeilingRenderer, { node: node }), node.type === 'level' && _jsx(LevelRenderer, { node: node }), node.type === 'item' && _jsx(ItemRenderer, { node: node }), node.type === 'slab' && _jsx(SlabRenderer, { node: node }), node.type === 'wall' && _jsx(WallRenderer, { node: node }), node.type === 'window' && _jsx(WindowRenderer, { node: node }), node.type === 'zone' && _jsx(ZoneRenderer, { node: node }), node.type === 'roof' && _jsx(RoofRenderer, { node: node }), node.type === 'scan' && _jsx(ScanRenderer, { node: node }), node.type === 'guide' && _jsx(GuideRenderer, { node: node })] }));
+    return (_jsxs(_Fragment, { children: [node.type === 'site' && _jsx(SiteRenderer, { node: node }), node.type === 'building' && _jsx(BuildingRenderer, { node: node }), node.type === 'ceiling' && _jsx(CeilingRenderer, { node: node }), node.type === 'level' && _jsx(LevelRenderer, { node: node }), node.type === 'item' && _jsx(ItemRenderer, { node: node }), node.type === 'slab' && _jsx(SlabRenderer, { node: node }), node.type === 'wall' && _jsx(WallRenderer, { node: node }), node.type === 'door' && _jsx(DoorRenderer, { node: node }), node.type === 'window' && _jsx(WindowRenderer, { node: node }), node.type === 'zone' && _jsx(ZoneRenderer, { node: node }), node.type === 'roof' && _jsx(RoofRenderer, { node: node }), node.type === 'roof-segment' && _jsx(RoofSegmentRenderer, { node: node }), node.type === 'scan' && _jsx(ScanRenderer, { node: node }), node.type === 'guide' && _jsx(GuideRenderer, { node: node })] }));
 };

package/dist/components/renderers/roof/roof-materials.d.ts

@@ -0,0 +1,4 @@
+import * as THREE from 'three';
+export declare const roofMaterials: THREE.Material[];
+export declare const roofDebugMaterials: THREE.Material[];
+//# sourceMappingURL=roof-materials.d.ts.map

package/dist/components/renderers/roof/roof-materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,QAAQ,EAKzC,CAAA;AAGD,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,QAAQ,EAK9C,CAAA"}

package/dist/components/renderers/roof/roof-materials.js

@@ -0,0 +1,16 @@
+import * as THREE from 'three';
+// Production materials — match the rest of the scene (white walls, light-gray slabs).
+// Indices: 0 = Wall/Trim, 1 = Deck, 2 = Interior, 3 = Shingle
+export const roofMaterials = [
+    new THREE.MeshStandardMaterial({ color: 'white', roughness: 1, side: THREE.DoubleSide }), // 0: Wall/Trim
+    new THREE.MeshStandardMaterial({ color: '#e5e5e5', roughness: 1, side: THREE.FrontSide }), // 1: Deck
+    new THREE.MeshStandardMaterial({ color: 'white', roughness: 1, side: THREE.DoubleSide }), // 2: Interior
+    new THREE.MeshStandardMaterial({ color: '#e5e5e5', roughness: 0.9, side: THREE.FrontSide }), // 3: Shingle
+];
+// Debug materials — vivid, distinct colours to identify each surface group.
+export const roofDebugMaterials = [
+    new THREE.MeshStandardMaterial({ color: '#eaeaea', roughness: 0.8, side: THREE.DoubleSide }), // 0: Wall
+    new THREE.MeshStandardMaterial({ color: '#000000', roughness: 0.9, side: THREE.FrontSide }), // 1: Deck
+    new THREE.MeshStandardMaterial({ color: '#dddddd', roughness: 0.9, side: THREE.DoubleSide }), // 2: Interior
+    new THREE.MeshStandardMaterial({ color: '#4ade80', roughness: 0.9, side: THREE.FrontSide }), // 3: Shingle
+];

package/dist/components/renderers/roof/roof-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/roof/roof-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,kBAAkB,CAAA;AAK7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,4CAsBxD,CAAA"}
+{"version":3,"file":"roof-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/roof/roof-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,kBAAkB,CAAA;AAQ7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,4CA+BxD,CAAA"}

package/dist/components/renderers/roof/roof-renderer.js

@@ -2,9 +2,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRegistry } from '@pascal-app/core';
 import { useRef } from 'react';
 import { useNodeEvents } from '../../../hooks/use-node-events';
+import useViewer from '../../../store/use-viewer';
+import { NodeRenderer } from '../node-renderer';
+import { roofDebugMaterials, roofMaterials } from './roof-materials';
 export const RoofRenderer = ({ node }) => {
     const ref = useRef(null);
     useRegistry(node.id, 'roof', ref);
     const handlers = useNodeEvents(node, 'roof');
-    return (_jsxs("mesh", { ref: ref, castShadow: true, receiveShadow: true, position: node.position, "rotation-y": node.rotation, visible: node.visible, ...handlers, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("meshStandardMaterial", { color: "white" })] }));
+    const debugColors = useViewer((s) => s.debugColors);
+    return (_jsxs("group", { position: node.position, ref: ref, "rotation-y": node.rotation, visible: node.visible, ...handlers, children: [_jsx("mesh", { castShadow: true, material: debugColors ? roofDebugMaterials : roofMaterials, name: "merged-roof", receiveShadow: true, children: _jsx("boxGeometry", { args: [0, 0, 0] }) }), _jsx("group", { name: "segments-wrapper", visible: false, children: (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))) })] }));
 };

package/dist/components/renderers/roof-segment/roof-segment-renderer.d.ts

@@ -0,0 +1,5 @@
+import { type RoofSegmentNode } from '@pascal-app/core';
+export declare const RoofSegmentRenderer: ({ node }: {
+    node: RoofSegmentNode;
+}) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=roof-segment-renderer.d.ts.map

package/dist/components/renderers/roof-segment/roof-segment-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-segment-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/roof-segment/roof-segment-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAe,MAAM,kBAAkB,CAAA;AAOpE,eAAO,MAAM,mBAAmB,GAAI,UAAU;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,4CAqBtE,CAAA"}

package/dist/components/renderers/roof-segment/roof-segment-renderer.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRegistry } from '@pascal-app/core';
+import { useRef } from 'react';
+import { useNodeEvents } from '../../../hooks/use-node-events';
+import useViewer from '../../../store/use-viewer';
+import { roofDebugMaterials, roofMaterials } from '../roof/roof-materials';
+export const RoofSegmentRenderer = ({ node }) => {
+    const ref = useRef(null);
+    useRegistry(node.id, 'roof-segment', ref);
+    const handlers = useNodeEvents(node, 'roof-segment');
+    const debugColors = useViewer((s) => s.debugColors);
+    return (_jsx("mesh", { material: debugColors ? roofDebugMaterials : roofMaterials, position: node.position, ref: ref, "rotation-y": node.rotation, visible: node.visible, ...handlers, children: _jsx("boxGeometry", { args: [0, 0, 0] }) }));
+};

package/dist/components/renderers/scan/scan-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/scan/scan-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,kBAAkB,CAAA;AAM7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,4CAoBxD,CAAA"}
+{"version":3,"file":"scan-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/scan/scan-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,kBAAkB,CAAA;AAO7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,4CAsBxD,CAAA"}

package/dist/components/renderers/scan/scan-renderer.js

@@ -3,11 +3,13 @@ import { useRegistry } from '@pascal-app/core';
 import { Suspense, useMemo, useRef } from 'react';
 import { useAssetUrl } from '../../../hooks/use-asset-url';
 import { useGLTFKTX2 } from '../../../hooks/use-gltf-ktx2';
+import useViewer from '../../../store/use-viewer';
 export const ScanRenderer = ({ node }) => {
+    const showScans = useViewer((s) => s.showScans);
     const ref = useRef(null);
     useRegistry(node.id, 'scan', ref);
     const resolvedUrl = useAssetUrl(node.url);
-    return (_jsx("group", { ref: ref, position: node.position, rotation: node.rotation, scale: [node.scale, node.scale, node.scale], children: resolvedUrl && (_jsx(Suspense, { children: _jsx(ScanModel, { url: resolvedUrl, opacity: node.opacity }) })) }));
+    return (_jsx("group", { position: node.position, ref: ref, rotation: node.rotation, scale: [node.scale, node.scale, node.scale], visible: showScans, children: resolvedUrl && (_jsx(Suspense, { children: _jsx(ScanModel, { opacity: node.opacity, url: resolvedUrl }) })) }));
 };
 const ScanModel = ({ url, opacity }) => {
     const gltf = useGLTFKTX2(url);

package/dist/components/renderers/scene-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-renderer.d.ts","sourceRoot":"","sources":["../../../src/components/renderers/scene-renderer.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,aAAa,+CAUzB,CAAC"}
+{"version":3,"file":"scene-renderer.d.ts","sourceRoot":"","sources":["../../../src/components/renderers/scene-renderer.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,aAAa,+CAUzB,CAAA"}

package/dist/components/renderers/scene-renderer.js

@@ -1,7 +1,7 @@
-"use client";
+'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useScene } from "@pascal-app/core";
-import { NodeRenderer } from "./node-renderer";
+import { useScene } from '@pascal-app/core';
+import { NodeRenderer } from './node-renderer';
 export const SceneRenderer = () => {
     const rootNodes = useScene((state) => state.rootNodeIds);
     return (_jsx("group", { name: "scene-renderer", children: rootNodes.map((nodeId) => (_jsx(NodeRenderer, { nodeId: nodeId }, nodeId))) }));

package/dist/components/renderers/site/site-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"site-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/site/site-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,kBAAkB,CAAA;AAiC7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,mDAwFxD,CAAA"}
+{"version":3,"file":"site-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/site/site-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,kBAAkB,CAAA;AA+B7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,mDA2DxD,CAAA"}

package/dist/components/renderers/site/site-renderer.js

@@ -1,12 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRegistry } from '@pascal-app/core';
-import { Html } from '@react-three/drei';
 import { useMemo, useRef } from 'react';
 import { BufferGeometry, Float32BufferAttribute, Shape } from 'three';
 import { useNodeEvents } from '../../../hooks/use-node-events';
 import { NodeRenderer } from '../node-renderer';
 const Y_OFFSET = 0.01;
-const LINE_HEIGHT = 0.5;
 /**
  * Creates simple line geometry for site boundary
  * Single horizontal line at ground level
@@ -18,10 +16,10 @@ const createBoundaryLineGeometry = (points) => {
     const positions = [];
     // Create a simple line loop at ground level
     for (const [x, z] of points) {
-        positions.push(x, Y_OFFSET, z);
+        positions.push(x ?? 0, Y_OFFSET, z ?? 0);
     }
     // Close the loop
-    positions.push(points[0][0], Y_OFFSET, points[0][1]);
+    positions.push(points[0]?.[0] ?? 0, Y_OFFSET, points[0]?.[1] ?? 0);
     geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
     return geometry;
 };
@@ -50,22 +48,9 @@ export const SiteRenderer = ({ node }) => {
             return null;
         return createBoundaryLineGeometry(node.polygon.points);
     }, [node?.polygon?.points]);
-    // Edge distances for labels
-    const edges = useMemo(() => {
-        const polygon = node?.polygon?.points ?? [];
-        if (polygon.length < 2)
-            return [];
-        return polygon.map(([x1, z1], i) => {
-            const [x2, z2] = polygon[(i + 1) % polygon.length];
-            const midX = (x1 + x2) / 2;
-            const midZ = (z1 + z2) / 2;
-            const dist = Math.sqrt((x2 - x1) ** 2 + (z2 - z1) ** 2);
-            return { midX, midZ, dist };
-        });
-    }, [node?.polygon?.points]);
     const handlers = useNodeEvents(node, 'site');
-    if (!node || !floorShape || !lineGeometry) {
+    if (!(node && floorShape && lineGeometry)) {
         return null;
     }
-    return (_jsxs("group", { ref: ref, ...handlers, children: [node.children.map((child) => (_jsx(NodeRenderer, { nodeId: typeof child === 'string' ? child : child.id }, typeof child === 'string' ? child : child.id))), _jsxs("mesh", { position: [0, Y_OFFSET - 0.005, 0], rotation: [-Math.PI / 2, 0, 0], receiveShadow: true, children: [_jsx("shapeGeometry", { args: [floorShape] }), _jsx("shadowMaterial", { transparent: true, opacity: 0.75 })] }), _jsx("line", { geometry: lineGeometry, frustumCulled: false, renderOrder: 9, children: _jsx("lineBasicMaterial", { color: "#f59e0b", linewidth: 2, transparent: true, opacity: 0.6 }) }), edges.map((edge, i) => (_jsx(Html, { center: true, position: [edge.midX, 0.5, edge.midZ], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [10, 0], occlude: true, children: _jsxs("div", { className: "whitespace-nowrap rounded bg-black/75 px-1.5 py-0.5 font-mono text-white text-xs backdrop-blur-sm", children: [edge.dist.toFixed(2), "m"] }) }, `edge-${i}`)))] }));
+    return (_jsxs("group", { ref: ref, ...handlers, children: [node.children.map((child) => (_jsx(NodeRenderer, { nodeId: typeof child === 'string' ? child : child.id }, typeof child === 'string' ? child : child.id))), _jsxs("mesh", { position: [0, Y_OFFSET - 0.005, 0], receiveShadow: true, rotation: [-Math.PI / 2, 0, 0], children: [_jsx("shapeGeometry", { args: [floorShape] }), _jsx("shadowMaterial", { opacity: 0.75, transparent: true })] }), _jsx("line", { frustumCulled: false, geometry: lineGeometry, renderOrder: 9, children: _jsx("lineBasicMaterial", { color: "#f59e0b", linewidth: 2, opacity: 0.6, transparent: true }) })] }));
 };

package/dist/components/renderers/slab/slab-renderer.js

@@ -6,5 +6,5 @@ export const SlabRenderer = ({ node }) => {
     const ref = useRef(null);
     useRegistry(node.id, 'slab', ref);
     const handlers = useNodeEvents(node, 'slab');
-    return (_jsxs("mesh", { ref: ref, castShadow: true, receiveShadow: true, ...handlers, visible: node.visible, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("meshStandardMaterial", { color: "#e5e5e5" })] }));
+    return (_jsxs("mesh", { castShadow: true, receiveShadow: true, ref: ref, ...handlers, visible: node.visible, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("meshStandardMaterial", { color: "#e5e5e5" })] }));
 };

package/dist/components/renderers/wall/wall-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/wall/wall-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAM7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,4CAoBxD,CAAA"}
+{"version":3,"file":"wall-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/wall/wall-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAM7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,4CAqBxD,CAAA"}

package/dist/components/renderers/wall/wall-renderer.js

@@ -7,5 +7,5 @@ export const WallRenderer = ({ node }) => {
     const ref = useRef(null);
     useRegistry(node.id, 'wall', ref);
     const handlers = useNodeEvents(node, 'wall');
-    return (_jsxs("mesh", { ref: ref, castShadow: true, receiveShadow: true, visible: node.visible, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("mesh", { name: "collision-mesh", ...handlers, visible: false, children: _jsx("boxGeometry", { args: [0, 0, 0] }) }), node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] }));
+    return (_jsxs("mesh", { castShadow: true, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("mesh", { name: "collision-mesh", visible: false, ...handlers, children: _jsx("boxGeometry", { args: [0, 0, 0] }) }), node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] }));
 };

package/dist/components/renderers/window/window-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"window-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/window/window-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAK/D,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,4CAqB5D,CAAA"}
+{"version":3,"file":"window-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/window/window-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAK/D,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,4CAsB5D,CAAA"}

package/dist/components/renderers/window/window-renderer.js

@@ -6,5 +6,6 @@ export const WindowRenderer = ({ node }) => {
     const ref = useRef(null);
     useRegistry(node.id, 'window', ref);
     const handlers = useNodeEvents(node, 'window');
-    return (_jsxs("mesh", { ref: ref, castShadow: true, receiveShadow: true, visible: node.visible, position: node.position, rotation: node.rotation, ...handlers, children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("meshStandardMaterial", { color: "#d1d5db" })] }));
+    const isTransient = !!node.metadata?.isTransient;
+    return (_jsxs("mesh", { castShadow: true, position: node.position, receiveShadow: true, ref: ref, rotation: node.rotation, visible: node.visible, ...(isTransient ? {} : handlers), children: [_jsx("boxGeometry", { args: [0, 0, 0] }), _jsx("meshStandardMaterial", { color: "#d1d5db" })] }));
 };

package/dist/components/renderers/zone/zone-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zone-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/zone/zone-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAwG7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,mDAoGxD,CAAA"}
+{"version":3,"file":"zone-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/zone/zone-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAyG7D,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,mDAqJxD,CAAA"}

package/dist/components/renderers/zone/zone-renderer.js

@@ -6,6 +6,7 @@ import { BufferGeometry, Color, DoubleSide, Float32BufferAttribute, Shape } from
 import { color, float, uniform, uv } from 'three/tsl';
 import { MeshBasicNodeMaterial } from 'three/webgpu';
 import { useNodeEvents } from '../../../hooks/use-node-events';
+import { ZONE_LAYER } from '../../../lib/layers';
 const Y_OFFSET = 0.01;
 const WALL_HEIGHT = 2.3;
 /**
@@ -24,11 +25,11 @@ const createWallGradientMaterial = (zoneColor) => {
         colorNode: baseColor,
         opacityNode: finalOpacity,
         side: DoubleSide,
-        depthWrite: false,
+        depthWrite: true,
         depthTest: false,
         userData: {
             uOpacity: opacity,
-        }
+        },
     });
 };
 /**
@@ -44,7 +45,7 @@ const createFloorMaterial = (zoneColor) => {
         side: DoubleSide,
         depthWrite: false,
         depthTest: false,
-        userData: { uOpacity: opacity }
+        userData: { uOpacity: opacity },
     });
 };
 /**
@@ -144,18 +145,37 @@ export const ZoneRenderer = ({ node }) => {
         return createWallGradientMaterial(node.color);
     }, [node?.color]);
     const handlers = useNodeEvents(node, 'zone');
-    if (!node || !floorShape || !wallGeometry || !floorMaterial || !wallMaterial) {
+    if (!(node && floorShape && wallGeometry && floorMaterial && wallMaterial)) {
         return null;
     }
-    return (_jsxs("group", { ref: ref, ...handlers, children: [_jsx(Html, { name: "label", position: [centroid[0], 1, centroid[1]], style: {
-                    pointerEvents: 'none'
-                }, zIndexRange: [10, 0], children: _jsx("div", { style: {
-                        transform: 'translate3d(-50%, -50%, 0)',
-                        width: 'max-content',
-                        color: 'white',
-                        textShadow: `-1px -1px 0 ${node.color}, 1px -1px 0 ${node.color}, -1px 1px 0 ${node.color}, 1px 1px 0 ${node.color}`,
+    return (_jsxs("group", { ref: ref, ...handlers, userData: { labelPosition: [centroid[0], 1, centroid[1]] }, children: [_jsx(Html, { name: "label", position: [centroid[0], 1, centroid[1]], style: { pointerEvents: 'none' }, zIndexRange: [10, 0], children: _jsxs("div", { id: `${node.id}-label`, style: {
                         display: 'flex',
-                        gap: '8px',
+                        flexDirection: 'column',
                         alignItems: 'center',
-                    }, children: node.name }) }), _jsx("mesh", { position: [0, Y_OFFSET, 0], rotation: [-Math.PI / 2, 0, 0], material: floorMaterial, name: "floor", children: _jsx("shapeGeometry", { args: [floorShape] }) }), _jsx("mesh", { geometry: wallGeometry, material: wallMaterial, name: "walls" })] }));
+                        transform: 'translate3d(-50%, -50%, 0)',
+                        opacity: 0,
+                        transition: 'opacity 0.3s ease-in-out',
+                    }, children: [_jsx("div", { style: {
+                                width: 'max-content',
+                                color: 'white',
+                                textShadow: `-1px -1px 0 ${node.color}, 1px -1px 0 ${node.color}, -1px 1px 0 ${node.color}, 1px 1px 0 ${node.color}`,
+                                textAlign: 'center',
+                            }, children: _jsx("span", { children: node.name }) }), _jsxs("div", { className: "label-pin", style: {
+                                display: 'flex',
+                                flexDirection: 'column',
+                                alignItems: 'center',
+                                marginTop: '2px',
+                                opacity: 0,
+                                transition: 'opacity 0.5s ease-in-out',
+                            }, children: [_jsx("div", { style: {
+                                        width: '2px',
+                                        height: '40px',
+                                        backgroundColor: node.color,
+                                    } }), _jsx("div", { style: {
+                                        width: '10px',
+                                        height: '10px',
+                                        borderRadius: '50%',
+                                        backgroundColor: node.color,
+                                        border: '1px solid white',
+                                    } })] })] }) }), _jsx("mesh", { layers: ZONE_LAYER, material: floorMaterial, name: "floor", position: [0, Y_OFFSET, 0], rotation: [-Math.PI / 2, 0, 0], children: _jsx("shapeGeometry", { args: [floorShape] }) }), _jsx("mesh", { geometry: wallGeometry, layers: ZONE_LAYER, material: wallMaterial, name: "walls" })] }));
 };

package/dist/components/viewer/ground-occluder.d.ts

@@ -0,0 +1,2 @@
+export declare const GroundOccluder: () => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ground-occluder.d.ts.map

package/dist/components/viewer/ground-occluder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-occluder.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/ground-occluder.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,+CAqE1B,CAAA"}