@pascal-app/viewer 0.8.0 → 0.9.1

package/dist/components/viewer/post-processing.js

@@ -5,8 +5,12 @@ import { ssgi } from 'three/addons/tsl/display/SSGINode.js';
 import { denoise } from 'three/examples/jsm/tsl/display/DenoiseNode.js';
 import { add, colorToDirection, diffuseColor, directionToColor, float, mix, mrt, normalView, oscSine, output, pass, sample, time, uniform, vec4, } from 'three/tsl';
 import { RenderPipeline } from 'three/webgpu';
-import { SCENE_LAYER, ZONE_LAYER } from '../../lib/layers';
+import { edgeColorFor } from '../../lib/edge-style';
+import { PERF_OVERLAY_ENABLED, pushGpuSample } from '../../lib/gpu-perf';
+import { inkedEdges } from '../../lib/ink-edges';
+import { GRID_LAYER, OVERLAY_LAYER, SCENE_LAYER, ZONE_LAYER } from '../../lib/layers';
 import { mergedOutline } from '../../lib/merged-outline-node';
+import { getSceneTheme } from '../../lib/scene-themes';
 import useViewer from '../../store/use-viewer';
 // SSGI Parameters - adjust these to fine-tune global illumination and ambient occlusion
 export const SSGI_PARAMS = {
@@ -23,10 +27,38 @@ export const SSGI_PARAMS = {
     useScreenSpaceSampling: true,
     useTemporalFiltering: false,
 };
+// Diagnostic toggles for thermal A/B testing. Add `?disable=ao,denoise,outline,postFx`
+// to the URL (any subset) and reload to skip those passes. Each flag prevents
+// allocation + per-frame work for that stage, so device temperature deltas
+// across combos isolate which pass is the actual culprit. Picked up once at
+// pipeline build; reload after changing the URL.
+//   - ao:      skip SSGI entirely (and denoise, since denoise has nothing to denoise)
+//   - denoise: keep SSGI but feed its raw noisy AO straight to the composite
+//   - outline: skip the merged-outline node and its 14 internal RTs
+//   - postFx:  bypass the whole RenderPipeline and use renderer.render(scene, camera)
+//              directly — isolates raw scene-render cost from any post-FX overhead
+function readPerfDisableFlags() {
+    if (typeof window === 'undefined') {
+        return { ao: false, denoise: false, outline: false, postFx: false };
+    }
+    const raw = new URLSearchParams(window.location.search).get('disable') ?? '';
+    const set = new Set(raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean));
+    return {
+        ao: set.has('ao'),
+        denoise: set.has('denoise'),
+        outline: set.has('outline'),
+        postFx: set.has('postFx'),
+    };
+}
+const PERF_POST_FX_DISABLED = typeof window !== 'undefined' &&
+    new Set((new URLSearchParams(window.location.search).get('disable') ?? '')
+        .split(',')
+        .map((s) => s.trim())).has('postFx');
 const MAX_PIPELINE_RETRIES = 3;
 const RETRY_DELAY_MS = 500;
-const DARK_BG = '#1f2433';
-const LIGHT_BG = '#ffffff';
 const DEFAULT_HOVER_STYLE = {
     visibleColor: 0x00_aa_ff,
     hiddenColor: 0xf3_ff_47,
@@ -48,23 +80,46 @@ function sanitizeOutlineObjects(objects) {
     objects.length = nextIndex;
 }
 const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
-    const { gl: renderer, invalidate, scene, camera } = useThree();
+    const { gl: renderer, invalidate, scene, camera, size } = useThree();
     const renderPipelineRef = useRef(null);
     const hasPipelineErrorRef = useRef(false);
     const retryCountRef = useRef(0);
     const rebuildTimeoutRef = useRef(null);
+    const skippedZeroSizeRef = useRef(false);
     // Background color uniform — updated every frame via lerp, read by the TSL pipeline.
-    // Initialised from the current theme so there's no flash on first render.
-    const initBg = useViewer.getState().theme === 'dark' ? DARK_BG : LIGHT_BG;
+    // Initialised from the current scene theme so there's no flash on first render.
+    const initBg = getSceneTheme(useViewer.getState().sceneTheme).background;
     const bgUniform = useRef(uniform(new Color(initBg)));
     const bgCurrent = useRef(new Color(initBg));
     const bgTarget = useRef(new Color());
+    // Ink-line colour follows the scene-theme background luminance (dark lines on
+    // light scenes, light on dark), refreshed each frame like the background.
+    const inkColorUniform = useRef(uniform(new Color(edgeColorFor(initBg))));
     const zoneLayers = useMemo(() => {
         const l = new Layers();
         l.enable(ZONE_LAYER);
         l.disable(SCENE_LAYER);
         return l;
     }, []);
+    // Scene pass renders the main geometry layer plus the grid. The default camera
+    // mask also has the overlay layer enabled (custom controls enable it for
+    // picking), so without this the gizmos/handles/tool previews land in the
+    // depth+normal MRT and get inked / AO'd as if they were geometry. The grid is
+    // kept in here (not the overlay pass) so scene geometry depth-occludes it; it's
+    // a flat, depth-non-writing plane so the ink never picks it up.
+    const sceneOnlyLayers = useMemo(() => {
+        const l = new Layers();
+        l.set(SCENE_LAYER);
+        l.enable(GRID_LAYER);
+        return l;
+    }, []);
+    // Editor overlays render in their own pass, composited on top after the ink
+    // and outlines so they read as crisp UI rather than scene geometry.
+    const overlayLayers = useMemo(() => {
+        const l = new Layers();
+        l.set(OVERLAY_LAYER);
+        return l;
+    }, []);
     const hoverHighlightMode = useViewer((s) => s.hoverHighlightMode);
     const hoverVisibleColor = useMemo(() => uniform(new Color(DEFAULT_HOVER_STYLE.visibleColor)), []);
     const hoverHiddenColor = useMemo(() => uniform(new Color(DEFAULT_HOVER_STYLE.hiddenColor)), []);
@@ -72,6 +127,9 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
     const hoverPulseMix = useMemo(() => uniform(DEFAULT_HOVER_STYLE.pulse ? 0 : 1), []);
     // Subscribe to projectId so the pipeline rebuilds on project switch
     const projectId = useViewer((s) => s.projectId);
+    const shading = useViewer((s) => s.shading);
+    const edges = useViewer((s) => s.edges);
+    const lastProjectIdRef = useRef(projectId);
     // Bump this to force a pipeline rebuild (used by retry logic)
     const [pipelineVersion, setPipelineVersion] = useState(0);
     const requestPipelineRebuild = useCallback(() => {
@@ -83,6 +141,9 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
     }, []);
     // Reset retry state when project changes
     useEffect(() => {
+        if (lastProjectIdRef.current === projectId)
+            return;
+        lastProjectIdRef.current = projectId;
         retryCountRef.current = 0;
         if (rebuildTimeoutRef.current !== null) {
             clearTimeout(rebuildTimeoutRef.current);
@@ -115,6 +176,8 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
     ]);
     // Build / rebuild the post-processing pipeline
     useEffect(() => {
+        const width = Math.floor(size.width);
+        const height = Math.floor(size.height);
         if (!(renderer && scene && camera)) {
             console.warn('[viewer/post-processing] Skipping pipeline build — missing dependency.', {
                 hasRenderer: !!renderer,
@@ -123,14 +186,60 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
             });
             return;
         }
+        if (width < 1 || height < 1) {
+            skippedZeroSizeRef.current = true;
+            hasPipelineErrorRef.current = false;
+            if (renderPipelineRef.current) {
+                renderPipelineRef.current.dispose();
+            }
+            renderPipelineRef.current = null;
+            return;
+        }
+        if (skippedZeroSizeRef.current) {
+            skippedZeroSizeRef.current = false;
+        }
+        const perfDisable = readPerfDisableFlags();
+        const ssgiEnabled = shading === 'rendered' && SSGI_PARAMS.enabled && !perfDisable.ao;
+        const denoiseEnabled = ssgiEnabled && !perfDisable.denoise;
+        const outlineEnabled = !perfDisable.outline;
+        const inkEnabled = edges !== 'off';
+        // The depth+normal MRT feeds both SSGI and the screen-space ink pass.
+        const needsNormalMRT = ssgiEnabled || inkEnabled;
+        // Soft = thin (1px sample radius) + faint (50% opacity); strong = thick
+        // (2px, ~2× wider detected band) + solid (100%). The edge masks saturate,
+        // so radius+opacity are what actually separate the two modes — gain wouldn't.
+        // Same 1px line thickness for both (soft's thickness is the nice one);
+        // strong reads heavier purely by being fully solid vs soft's lighter 50%.
+        const inkRadius = 1;
+        const inkOpacity = edges === 'strong' ? 1 : 0.5;
         console.log('[viewer/post-processing] Building pipeline', {
             version: pipelineVersion,
-            ssgi: SSGI_PARAMS.enabled,
+            ssgi: ssgiEnabled,
+            denoise: denoiseEnabled,
+            outline: outlineEnabled,
+            perfDisable,
             hoverHighlightMode,
             projectId,
+            shading,
             rendererCtor: renderer.constructor?.name,
+            width,
+            height,
         });
         hasPipelineErrorRef.current = false;
+        // WebGPU availability check: SSGI, denoise, and RenderPipeline are all
+        // WebGPU-only APIs. When the browser falls back to WebGL2 (no
+        // `navigator.gpu`, or the device couldn't be created), building the
+        // pipeline either throws silently or produces a broken output where
+        // the scene renders for a few frames and then goes black as the retry
+        // loop fights the direct-render fallback path. Short-circuit here so
+        // `useFrame` uses the direct `renderer.render(scene, camera)` path
+        // exclusively and never attempts the TSL pipeline.
+        const hasWebGPU = typeof navigator !== 'undefined' && 'gpu' in navigator;
+        if (!hasWebGPU) {
+            hasPipelineErrorRef.current = true;
+            renderPipelineRef.current = null;
+            return;
+        }
         // Clear outliner arrays synchronously to prevent stale Object3D refs
         // from the previous project leaking into the new pipeline's outline passes.
         const outliner = useViewer.getState().outliner;
@@ -140,8 +249,15 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
         outliner.hoveredObjects.length = 0;
         try {
             const scenePass = pass(scene, camera);
+            scenePass.setLayers(sceneOnlyLayers);
             const zonePass = pass(scene, camera);
             zonePass.setLayers(zoneLayers);
+            // Editor overlays (gizmos, move handles, tool previews, grid) on their own
+            // layer, kept out of the depth/normal MRT above so the ink + SSGI ignore
+            // them, then composited on top of the final image below.
+            const overlayPass = pass(scene, camera);
+            overlayPass.setLayers(overlayLayers);
+            const overlayColor = overlayPass.getTextureNode('output');
             const scenePassColor = scenePass.getTextureNode('output');
             // Background detection via alpha: renderer clears with alpha=0 (setClearAlpha(0) in useFrame),
             // so background pixels have scenePassColor.a=0 while geometry pixels have output.a=1.
@@ -150,23 +266,28 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
             const hasGeometry = scenePassColor.a;
             const contentAlpha = hasGeometry.max(zonePass.a);
             let sceneColor = scenePassColor;
-            if (SSGI_PARAMS.enabled) {
-                // MRT only needed for SSGI (diffuse for GI, normal for SSGI sampling)
+            // Depth + normal MRT — shared by SSGI (diffuse/normal) and the ink pass
+            // (depth/normal). Built whenever either is active.
+            let scenePassDepth = null;
+            let scenePassNormal = null;
+            let sceneNormal = null;
+            if (needsNormalMRT) {
                 scenePass.setMRT(mrt({
                     output,
                     diffuseColor,
                     normal: directionToColor(normalView),
                 }));
+                scenePassDepth = scenePass.getTextureNode('depth');
+                scenePassNormal = scenePass.getTextureNode('normal');
+                const normalTexture = scenePass.getTexture('normal');
+                normalTexture.type = UnsignedByteType;
+                // Extract normal from color-encoded texture (SSGI consumes the node form)
+                sceneNormal = sample((uv) => colorToDirection(scenePassNormal.sample(uv)));
+            }
+            if (ssgiEnabled) {
                 const scenePassDiffuse = scenePass.getTextureNode('diffuseColor');
-                const scenePassDepth = scenePass.getTextureNode('depth');
-                const scenePassNormal = scenePass.getTextureNode('normal');
-                // Optimize texture bandwidth
                 const diffuseTexture = scenePass.getTexture('diffuseColor');
                 diffuseTexture.type = UnsignedByteType;
-                const normalTexture = scenePass.getTexture('normal');
-                normalTexture.type = UnsignedByteType;
-                // Extract normal from color-encoded texture
-                const sceneNormal = sample((uv) => colorToDirection(scenePassNormal.sample(uv)));
                 const giPass = ssgi(scenePassColor, scenePassDepth, sceneNormal, camera);
                 giPass.sliceCount.value = SSGI_PARAMS.sliceCount;
                 giPass.stepCount.value = SSGI_PARAMS.stepCount;
@@ -180,49 +301,76 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
                 giPass.useScreenSpaceSampling.value = SSGI_PARAMS.useScreenSpaceSampling;
                 giPass.useTemporalFiltering = SSGI_PARAMS.useTemporalFiltering;
                 const giTexture = giPass.getTextureNode();
-                // DenoiseNode only denoises RGB — alpha is passed through unchanged.
-                // SSGI packs AO into alpha, so we remap it into RGB before denoising.
-                const aoAsRgb = vec4(giTexture.a, giTexture.a, giTexture.a, float(1));
-                const denoisePass = denoise(aoAsRgb, scenePassDepth, sceneNormal, camera);
-                denoisePass.index.value = 0;
-                denoisePass.radius.value = 4;
                 const gi = giPass.rgb;
-                const ao = denoisePass.r;
+                let ao;
+                if (denoiseEnabled) {
+                    // DenoiseNode only denoises RGB — alpha is passed through unchanged.
+                    // SSGI packs AO into alpha, so we remap it into RGB before denoising.
+                    const aoAsRgb = vec4(giTexture.a, giTexture.a, giTexture.a, float(1));
+                    const denoisePass = denoise(aoAsRgb, scenePassDepth, sceneNormal, camera);
+                    denoisePass.index.value = 0;
+                    denoisePass.radius.value = 4;
+                    ao = denoisePass.r;
+                }
+                else {
+                    // Diagnostic path: feed raw noisy SSGI AO straight through. Will
+                    // look grainy — that's the point, it isolates denoise cost.
+                    ao = giTexture.a;
+                }
                 // Composite: scene * AO + diffuse * GI
                 sceneColor = vec4(add(scenePassColor.rgb.mul(ao), add(zonePass.rgb, scenePassDiffuse.rgb.mul(gi))), contentAlpha);
             }
+            // Screen-space ink outline (SketchUp look) — depth/normal edge detection
+            // over the composited scene. Topology-agnostic, so it handles CSG-cut
+            // walls cleanly. Applied before the selection outline + background mix.
+            if (inkEnabled) {
+                sceneColor = vec4(inkedEdges({
+                    sceneRgb: sceneColor.rgb,
+                    depthTex: scenePassDepth,
+                    normalTex: scenePassNormal,
+                    inkColor: inkColorUniform.current,
+                    radius: inkRadius,
+                    opacity: inkOpacity,
+                }), sceneColor.a);
+            }
             // Single merged outline node: one shared depth pass for both selected + hovered groups.
             const outliner = useViewer.getState().outliner;
-            const outlineNode = mergedOutline(scene, camera, {
-                primaryObjects: outliner.selectedObjects,
-                secondaryObjects: outliner.hoveredObjects,
-                primaryEdgeThickness: uniform(1),
-                secondaryEdgeThickness: uniform(1.5),
-            });
-            // Selected: white visible, yellow hidden
-            const selectedVisibleColor = uniform(new Color(0xff_ff_ff));
-            const selectedHiddenColor = uniform(new Color(0xf3_ff_47));
-            const selectedStrength = uniform(3);
-            const selectedOutline = outlineNode.primaryVisibleEdge
-                .mul(selectedVisibleColor)
-                .add(outlineNode.primaryHiddenEdge.mul(selectedHiddenColor))
-                .mul(selectedStrength);
-            // Hovered: blue visible, yellow hidden, pulsing
-            const pulsePeriod = uniform(3);
-            const oscillating = oscSine(time.div(pulsePeriod).mul(2)).mul(0.5).add(0.5);
-            const osc = mix(oscillating, float(1), hoverPulseMix);
-            const hoverOutline = outlineNode.secondaryVisibleEdge
-                .mul(hoverVisibleColor)
-                .add(outlineNode.secondaryHiddenEdge.mul(hoverHiddenColor))
-                .mul(hoverStrength)
-                .mul(osc);
-            const compositeWithOutlines = vec4(add(sceneColor.rgb, selectedOutline.add(hoverOutline)), sceneColor.a);
-            const finalOutput = vec4(mix(bgUniform.current, compositeWithOutlines.rgb, contentAlpha), float(1));
+            let compositeWithOutlines = sceneColor;
+            if (outlineEnabled) {
+                const outlineNode = mergedOutline(scene, camera, {
+                    primaryObjects: outliner.selectedObjects,
+                    secondaryObjects: outliner.hoveredObjects,
+                    primaryEdgeThickness: uniform(1),
+                    secondaryEdgeThickness: uniform(1.5),
+                });
+                // Selected: white visible, yellow hidden
+                const selectedVisibleColor = uniform(new Color(0xff_ff_ff));
+                const selectedHiddenColor = uniform(new Color(0xf3_ff_47));
+                const selectedStrength = uniform(3);
+                const selectedOutline = outlineNode.primaryVisibleEdge
+                    .mul(selectedVisibleColor)
+                    .add(outlineNode.primaryHiddenEdge.mul(selectedHiddenColor))
+                    .mul(selectedStrength);
+                // Hovered: blue visible, yellow hidden, pulsing
+                const pulsePeriod = uniform(3);
+                const oscillating = oscSine(time.div(pulsePeriod).mul(2)).mul(0.5).add(0.5);
+                const osc = mix(oscillating, float(1), hoverPulseMix);
+                const hoverOutline = outlineNode.secondaryVisibleEdge
+                    .mul(hoverVisibleColor)
+                    .add(outlineNode.secondaryHiddenEdge.mul(hoverHiddenColor))
+                    .mul(hoverStrength)
+                    .mul(osc);
+                compositeWithOutlines = vec4(add(sceneColor.rgb, selectedOutline.add(hoverOutline)), sceneColor.a);
+            }
+            const composited = mix(bgUniform.current, compositeWithOutlines.rgb, contentAlpha);
+            // Editor overlays painted on top by their own alpha — they never get inked,
+            // AO'd, or outlined, and always read crisp regardless of scene depth.
+            const withOverlay = mix(composited, overlayColor.rgb, overlayColor.a);
+            const finalOutput = vec4(withOverlay, float(1));
             const renderPipeline = new RenderPipeline(renderer);
             renderPipeline.outputNode = finalOutput;
             renderPipelineRef.current = renderPipeline;
             retryCountRef.current = 0;
-            console.log('[viewer/post-processing] Pipeline built OK', { version: pipelineVersion });
         }
         catch (error) {
             hasPipelineErrorRef.current = true;
@@ -245,31 +393,49 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
     }, [
         camera,
         hoverHiddenColor,
+        hoverHighlightMode,
         hoverPulseMix,
         hoverStrength,
         hoverVisibleColor,
+        edges,
         pipelineVersion,
         projectId,
         renderer,
         scene,
+        shading,
+        size.height,
+        size.width,
         zoneLayers,
+        sceneOnlyLayers,
+        overlayLayers,
     ]);
     useFrame((_, delta) => {
-        // Animate background colour toward the current theme target (same lerp as AnimatedBackground)
-        bgTarget.current.set(useViewer.getState().theme === 'dark' ? DARK_BG : LIGHT_BG);
+        if (size.width < 1 || size.height < 1) {
+            return;
+        }
+        // Animate background colour toward the current scene theme target (same lerp as AnimatedBackground)
+        bgTarget.current.set(getSceneTheme(useViewer.getState().sceneTheme).background);
         bgCurrent.current.lerp(bgTarget.current, Math.min(delta, 0.1) * 4);
         bgUniform.current.value.copy(bgCurrent.current);
+        // Ink colour follows the (lerping) background luminance — snaps dark↔light.
+        inkColorUniform.current.value.set(edgeColorFor(`#${bgCurrent.current.getHexString()}`));
         const outliner = useViewer.getState().outliner;
         sanitizeOutlineObjects(outliner.selectedObjects);
         sanitizeOutlineObjects(outliner.hoveredObjects);
-        if (hasPipelineErrorRef.current || !renderPipelineRef.current) {
+        if (PERF_POST_FX_DISABLED || hasPipelineErrorRef.current || !renderPipelineRef.current) {
             try {
                 if (renderer.setClearAlpha) {
                     ;
                     renderer.setClearAlpha(1);
                 }
-                ;
+                const submittedAt = PERF_OVERLAY_ENABLED ? performance.now() : 0;
                 renderer.render(scene, camera);
+                if (PERF_OVERLAY_ENABLED) {
+                    const queue = renderer.backend?.device?.queue;
+                    queue?.onSubmittedWorkDone?.().then(() => {
+                        pushGpuSample(performance.now() - submittedAt);
+                    });
+                }
             }
             catch (fallbackError) {
                 console.error('[viewer/post-processing] Fallback render failed.', fallbackError);
@@ -281,7 +447,19 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
             // making scenePassColor.a a reliable geometry mask (geometry pixels write a=1 via output node).
             ;
             renderer.setClearAlpha(0);
+            const submittedAt = PERF_OVERLAY_ENABLED ? performance.now() : 0;
             renderPipelineRef.current.render();
+            if (PERF_OVERLAY_ENABLED) {
+                // device.queue.onSubmittedWorkDone() resolves once the GPU has
+                // finished the work we just submitted — the delta from our submit
+                // timestamp is a clean per-frame GPU duration. Doesn't block CPU
+                // (no await) and works for the custom RenderPipeline path that
+                // bypasses three.js's timestamp-query infrastructure.
+                const queue = renderer.backend?.device?.queue;
+                queue?.onSubmittedWorkDone?.().then(() => {
+                    pushGpuSample(performance.now() - submittedAt);
+                });
+            }
         }
         catch (error) {
             hasPipelineErrorRef.current = true;
@@ -297,7 +475,6 @@ const PostProcessingPasses = ({ hoverStyles = DEFAULT_HOVER_STYLES, }) => {
             if (retryCountRef.current < MAX_PIPELINE_RETRIES) {
                 // Auto-retry: schedule a pipeline rebuild if we haven't exceeded the retry limit
                 retryCountRef.current++;
-                console.warn(`[viewer/post-processing] Scheduling pipeline rebuild (attempt ${retryCountRef.current}/${MAX_PIPELINE_RETRIES})`);
                 if (rebuildTimeoutRef.current !== null) {
                     clearTimeout(rebuildTimeoutRef.current);
                 }

package/dist/components/viewer/registered-systems.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Mounts every registered node kind's system component, ordered by
+ * `system.priority` (default {@link DEFAULT_PRIORITY}).
+ *
+ * Today the registry is empty so this component mounts nothing — coexists
+ * with legacy `*-System` components in `<Viewer>`. Once kinds register via
+ * `@pascal-app/nodes`, each kind's registry-driven system takes over and
+ * its legacy counterpart short-circuits via the `nodeRegistry.has(kind)`
+ * guard added to each legacy system.
+ */
+export declare function RegisteredSystems(): import("react").JSX.Element | null;
+//# sourceMappingURL=registered-systems.d.ts.map

package/dist/components/viewer/registered-systems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registered-systems.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/registered-systems.tsx"],"names":[],"mappings":"AAoBA;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,uCAsBhC"}

package/dist/components/viewer/registered-systems.js

@@ -0,0 +1,47 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { nodeRegistry } from '@pascal-app/core';
+import { lazy, Suspense, useMemo } from 'react';
+const DEFAULT_PRIORITY = 5;
+// Cache lazy components keyed by the module-loader function so React.lazy
+// isn't re-invoked across renders.
+const lazyCache = new WeakMap();
+function loadSystem(def) {
+    if (!def.system)
+        return null;
+    const cached = lazyCache.get(def.system.module);
+    if (cached)
+        return cached;
+    const Comp = lazy(def.system.module);
+    lazyCache.set(def.system.module, Comp);
+    return Comp;
+}
+/**
+ * Mounts every registered node kind's system component, ordered by
+ * `system.priority` (default {@link DEFAULT_PRIORITY}).
+ *
+ * Today the registry is empty so this component mounts nothing — coexists
+ * with legacy `*-System` components in `<Viewer>`. Once kinds register via
+ * `@pascal-app/nodes`, each kind's registry-driven system takes over and
+ * its legacy counterpart short-circuits via the `nodeRegistry.has(kind)`
+ * guard added to each legacy system.
+ */
+export function RegisteredSystems() {
+    const entries = useMemo(() => {
+        return Array.from(nodeRegistry.entries())
+            .filter(([, def]) => def.system != null)
+            .sort(([, a], [, b]) => {
+            const pa = a.system?.priority ?? DEFAULT_PRIORITY;
+            const pb = b.system?.priority ?? DEFAULT_PRIORITY;
+            return pa - pb;
+        });
+    }, []);
+    if (entries.length === 0)
+        return null;
+    return (_jsx(Suspense, { fallback: null, children: entries.map(([kind, def]) => {
+            const Comp = loadSystem(def);
+            if (!Comp)
+                return null;
+            return _jsx(Comp, {}, `registered-system:${kind}`);
+        }) }));
+}

package/dist/components/viewer/scene-bvh.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import { type Group } from 'three';
+import { type SplitStrategy } from 'three-mesh-bvh';
+type SceneBvhProps = {
+    children?: ReactNode;
+    enabled?: boolean;
+    firstHitOnly?: boolean;
+    strategy?: SplitStrategy;
+    verbose?: boolean;
+    setBoundingBox?: boolean;
+    maxDepth?: number;
+    maxLeafSize?: number;
+    indirect?: boolean;
+};
+export declare const SceneBvh: import("react").ForwardRefExoticComponent<SceneBvhProps & import("react").RefAttributes<Group<import("three").Object3DEventMap>>>;
+export {};
+//# sourceMappingURL=scene-bvh.d.ts.map

package/dist/components/viewer/scene-bvh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-bvh.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/scene-bvh.tsx"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,SAAS,EAA0C,MAAM,OAAO,CAAA;AAC1F,OAAO,EAAuB,KAAK,KAAK,EAAQ,MAAM,OAAO,CAAA;AAC7D,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAA;AAEvB,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,EAAE,aAAa,CAAA;IACxB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAeD,eAAO,MAAM,QAAQ,mIAmGpB,CAAA"}

package/dist/components/viewer/scene-bvh.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useThree } from '@react-three/fiber';
+import { forwardRef, useEffect, useImperativeHandle, useRef } from 'react';
+import { Mesh } from 'three';
+import { acceleratedRaycast, computeBoundsTree, disposeBoundsTree, SAH, } from 'three-mesh-bvh';
+const isMesh = (object) => !!object && typeof object === 'object' && object.isMesh === true;
+const hasBvhCompatibleGeometry = (geometry) => {
+    if (!geometry)
+        return false;
+    const position = geometry.getAttribute('position');
+    if (!position)
+        return false;
+    const vertexCount = geometry.getIndex()?.count ?? position.count;
+    return vertexCount >= 3;
+};
+export const SceneBvh = forwardRef(({ children, enabled = true, firstHitOnly = false, strategy = SAH, verbose = false, setBoundingBox = true, maxDepth = 40, maxLeafSize = 10, indirect = false, }, forwardedRef) => {
+    const ref = useRef(null);
+    const raycaster = useThree((state) => state.raycaster);
+    useImperativeHandle(forwardedRef, () => ref.current, []);
+    useEffect(() => {
+        if (!enabled || !ref.current)
+            return;
+        const options = {
+            strategy,
+            verbose,
+            setBoundingBox,
+            maxDepth,
+            maxLeafSize,
+            indirect,
+        };
+        const group = ref.current;
+        const acceleratedMeshes = new Set();
+        const computedGeometries = new Set();
+        raycaster.firstHitOnly = firstHitOnly;
+        group.traverse((child) => {
+            if (!isMesh(child))
+                return;
+            if (child.raycast === Mesh.prototype.raycast) {
+                child.raycast = acceleratedRaycast;
+                acceleratedMeshes.add(child);
+            }
+            if (child.raycast !== acceleratedRaycast)
+                return;
+            const geometry = child.geometry;
+            if (geometry.boundsTree || !hasBvhCompatibleGeometry(geometry))
+                return;
+            try {
+                // The three-mesh-bvh + @types/three combo doesn't agree on
+                // BVH option / class identity (ComputeBVHOptions vs
+                // MeshBVHOptions, GeometryBVH vs MeshBVH) — cast through
+                // `unknown` to bypass the structural mismatch. Runtime is
+                // fine; we're just calling the library's own helpers.
+                ;
+                geometry.computeBoundsTree =
+                    computeBoundsTree;
+                geometry.disposeBoundsTree =
+                    disposeBoundsTree;
+                geometry.computeBoundsTree(options);
+                computedGeometries.add(geometry);
+            }
+            catch (error) {
+                console.warn('[viewer] Skipping BVH for incompatible mesh geometry.', {
+                    mesh: child.name || child.type,
+                    error,
+                });
+            }
+        });
+        return () => {
+            delete raycaster.firstHitOnly;
+            for (const geometry of computedGeometries) {
+                if (geometry.boundsTree) {
+                    geometry.disposeBoundsTree();
+                }
+            }
+            for (const mesh of acceleratedMeshes) {
+                if (mesh.raycast === acceleratedRaycast) {
+                    mesh.raycast = Mesh.prototype.raycast;
+                }
+            }
+        };
+    }, [
+        enabled,
+        firstHitOnly,
+        strategy,
+        verbose,
+        setBoundingBox,
+        maxDepth,
+        maxLeafSize,
+        indirect,
+        raycaster,
+    ]);
+    return _jsx("group", { ref: ref, children: children });
+});
+SceneBvh.displayName = 'SceneBvh';

package/dist/components/viewer/selection-manager.d.ts

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

package/dist/components/viewer/selection-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection-manager.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/selection-manager.tsx"],"names":[],"mappings":"AAoSA,eAAO,MAAM,gBAAgB,+CA4E5B,CAAA"}
+{"version":3,"file":"selection-manager.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/selection-manager.tsx"],"names":[],"mappings":"AA0SA,eAAO,MAAM,gBAAgB,mCA0F5B,CAAA"}