@pascal-app/viewer 0.9.1 → 1.0.0-beta.1

package/dist/components/viewer/index.js

@@ -2,12 +2,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { nodeRegistry, StairOpeningSystem, sceneRegistry, useScene, } from '@pascal-app/core';
 import { Canvas, extend, useFrame, useThree } from '@react-three/fiber';
-import { forwardRef, useEffect, useImperativeHandle, useRef } from 'react';
+import { forwardRef, useEffect, useImperativeHandle, useLayoutEffect, useRef, useState, } from 'react';
 import * as THREE from 'three/webgpu';
 import { hasDrawableGeometry } from '../../lib/drawable-geometry';
 import { PERF_OVERLAY_ENABLED, pushGpuSample } from '../../lib/gpu-perf';
 import { applyIsolation, clearIsolation } from '../../lib/isolation';
+import { ensureKtx2Support } from '../../lib/ktx2-loader';
 import { getSceneTheme } from '../../lib/scene-themes';
+import { installTextureNodeNullGuard } from '../../lib/texture-node-guard';
 import useViewer, {} from '../../store/use-viewer';
 import { FloorElevationSystem } from '../../systems/floor-elevation/floor-elevation-system';
 import { GeometrySystem } from '../../systems/geometry/geometry-system';
@@ -21,6 +23,9 @@ import { RegisteredSystems } from './registered-systems';
 import { SceneBvh } from './scene-bvh';
 import { SelectionManager } from './selection-manager';
 import { ViewerCamera } from './viewer-camera';
+// Must be in place before any node material builds — a null texture pulled by
+// a shared override-material pass otherwise kills the render pass outright.
+installTextureNodeNullGuard();
 extend(THREE);
 // R3F's <Canvas> useLayoutEffect has no deps, so any re-render (theme switch,
 // parent re-render, StrictMode double-mount) re-invokes `configure()`. With a
@@ -51,6 +56,27 @@ const DIRTY_BUILD_KINDS = new Set([
     'window',
 ]);
 const warnedEmptyDraw = process.env.NODE_ENV === 'production' ? null : new WeakSet();
+function canCreateWebGLContext() {
+    if (typeof document === 'undefined')
+        return false;
+    const canvas = document.createElement('canvas');
+    try {
+        return Boolean(canvas.getContext('webgl2') ?? canvas.getContext('webgl'));
+    }
+    catch {
+        return false;
+    }
+}
+function canMountGpuViewer() {
+    if (typeof window === 'undefined')
+        return false;
+    if (!('gpu' in navigator) && !canCreateWebGLContext())
+        return false;
+    return true;
+}
+function UnsupportedGpuViewerFallback() {
+    return (_jsx("div", { className: "flex h-full min-h-64 w-full items-center justify-center bg-[#fafafa] p-6 text-center text-neutral-900", children: _jsxs("div", { className: "max-w-md rounded-2xl border border-neutral-200 bg-white p-6 shadow-sm", children: [_jsx("h2", { className: "font-semibold text-lg", children: "3D viewer unavailable" }), _jsx("p", { className: "mt-2 text-neutral-600 text-sm", children: "This browser or environment does not expose WebGPU or WebGL, so Pascal cannot render the 3D scene here. Try opening the editor in a browser with hardware acceleration enabled." })] }) }));
+}
 /**
  * Renderer-level safety net against the empty-vertex-buffer crash.
  *
@@ -83,6 +109,10 @@ function installEmptyDrawGuard(renderer) {
 function GPUDeviceWatcher() {
     const gl = useThree((s) => s.gl);
     useEffect(() => {
+        // Detect KTX2 transcode support as soon as the renderer exists, so catalog
+        // `.ktx2` finish textures load even in scenes with no GLB items (whose
+        // loader would otherwise be the only thing to call this).
+        ensureKtx2Support(gl);
         const backend = gl.backend;
         const device = backend?.device;
         if (!device) {
@@ -123,11 +153,23 @@ function ToneMappingExposure() {
     return null;
 }
 function hasPendingSceneBuildWork() {
-    const { dirtyNodes, nodes } = useScene.getState();
+    const { dirtyNodes, nodes, rootNodeIds } = useScene.getState();
     for (const id of dirtyNodes) {
         const node = nodes[id];
         if (!node)
             continue;
+        // Unreachable nodes (orphaned by a broken detach: the parent doesn't list
+        // them in `children`, or no parent and not a root) never render — every
+        // renderer enumerates the parent's `children` array — so no system will
+        // ever build them or clear their mark. They must not hold scene-ready
+        // hostage (observed in prod scene data: two dangling windows kept every
+        // bake of that scene waiting out the full readiness cap).
+        const parent = node.parentId ? nodes[node.parentId] : undefined;
+        const reachable = parent
+            ? parent.children?.includes(id) === true
+            : rootNodeIds.includes(id);
+        if (!reachable)
+            continue;
         const def = nodeRegistry.get(node.type);
         if (def?.geometry || def?.capabilities?.floorPlaced || DIRTY_BUILD_KINDS.has(node.type)) {
             return true;
@@ -141,10 +183,12 @@ function hasCommittedSceneRoot() {
         return Object.keys(nodes).length === 0;
     return rootNodeIds.some((id) => sceneRegistry.nodes.has(id));
 }
-function SceneReadyTracker({ onSceneReadyChange, sceneReadyKey, }) {
+function SceneReadyTracker({ onSceneReadyChange, sceneReadyKey, sceneReadyMaxWaitMs, }) {
+    const invalidate = useThree((state) => state.invalidate);
     const readyRef = useRef(false);
     const settledFramesRef = useRef(0);
     const waitedFramesRef = useRef(0);
+    const waitStartRef = useRef(null);
     const onSceneReadyChangeRef = useRef(onSceneReadyChange);
     useEffect(() => {
         onSceneReadyChangeRef.current = onSceneReadyChange;
@@ -154,26 +198,44 @@ function SceneReadyTracker({ onSceneReadyChange, sceneReadyKey, }) {
         readyRef.current = false;
         settledFramesRef.current = 0;
         waitedFramesRef.current = 0;
+        waitStartRef.current = null;
         onSceneReadyChangeRef.current?.(false);
-    }, [sceneReadyKey]);
+        invalidate();
+    }, [invalidate, sceneReadyKey]);
     useFrame(() => {
         if (!(onSceneReadyChangeRef.current && !readyRef.current))
             return;
         waitedFramesRef.current += 1;
-        if (waitedFramesRef.current < SCENE_READY_MAX_WAIT_FRAMES &&
-            (!hasCommittedSceneRoot() || hasPendingSceneBuildWork())) {
+        waitStartRef.current ??= performance.now();
+        // Give-up cap so a permanently-dirty node can't block readiness forever.
+        // The frame-count default assumes display-rate frames; a host whose frame
+        // cadence is decoupled from wall time (the headless bake page's timer-driven
+        // loop runs 180 frames in 3.6s — faster than a cold item download) passes
+        // `sceneReadyMaxWaitMs` to make the cap wall-clock instead.
+        const capReached = sceneReadyMaxWaitMs
+            ? performance.now() - waitStartRef.current >= sceneReadyMaxWaitMs
+            : waitedFramesRef.current >= SCENE_READY_MAX_WAIT_FRAMES;
+        if (!capReached && (!hasCommittedSceneRoot() || hasPendingSceneBuildWork())) {
             settledFramesRef.current = 0;
+            invalidate();
             return;
         }
         settledFramesRef.current += 1;
-        if (settledFramesRef.current < SCENE_READY_SETTLED_FRAMES)
+        if (settledFramesRef.current < SCENE_READY_SETTLED_FRAMES) {
+            invalidate();
             return;
+        }
         readyRef.current = true;
         onSceneReadyChangeRef.current(true);
     }, 10);
     return null;
 }
-const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVER_STYLES, selectionManager = 'default', perf = false, useBvh = true, renderContext = 'editor', defaultRender, isolate, sceneReadyKey, onSceneReadyChange, }, ref) {
+const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVER_STYLES, selectionManager = 'default', perf = false, useBvh = true, renderContext = 'editor', transparent, defaultRender, isolate, sceneReadyKey, onSceneReadyChange, sceneReadyMaxWaitMs, disablePostFx = false, }, ref) {
+    useEffect(() => {
+        if (nodeRegistry.size === 0) {
+            console.warn('[viewer] Node registry is empty. Install @pascal-app/nodes and call await loadPlugin(builtinPlugin) before mounting <Viewer>.');
+        }
+    }, []);
     useImperativeHandle(ref, () => ({
         setIsolated: (ids) => applyIsolation(ids),
     }), []);
@@ -191,7 +253,34 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
                 clearIsolation();
         };
     }, [isolate]);
+    const [rendererInitFailed, setRendererInitFailed] = useState(false);
+    // Capability detection runs after mount. We start optimistic (true) so the
+    // server-rendered markup and the first client render agree (no hydration
+    // mismatch); the effect flips it to false only on environments that expose
+    // neither WebGPU nor WebGL.
+    const [canMountViewer, setCanMountViewer] = useState(true);
+    useEffect(() => {
+        if (!canMountGpuViewer())
+            setCanMountViewer(false);
+    }, []);
     const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
+    const transparentBackground = useViewer((state) => state.transparentBackground);
+    // The shadows toggle drives `renderer.shadowMap.enabled` (via the Canvas
+    // `shadows` prop) rather than the lights' `castShadow`: toggling castShadow
+    // off disposes the shadow map's GPU texture but three r184's WebGPU node
+    // cache keeps the shadows-on builder state that references it, so toggling
+    // back on reuses destroyed resources and every frame submit fails with a
+    // GPUValidationError. Disabling at the renderer level rebuilds materials
+    // without disposing anything, so the round-trip is safe.
+    const shadowsEnabled = useViewer((state) => state.shadows);
+    useLayoutEffect(() => {
+        if (transparent === undefined)
+            return;
+        useViewer.getState().setTransparentBackground(transparent);
+        return () => {
+            useViewer.getState().setTransparentBackground(false);
+        };
+    }, [transparent]);
     const defaultShading = defaultRender?.shading;
     const defaultTextures = defaultRender?.textures;
     const defaultColorPreset = defaultRender?.colorPreset;
@@ -228,14 +317,25 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
     // fragment-shader cost down — saves another ~30% over 1.5x on high-DPI mobile.
     // Desktops (fine pointer) keep the original 1.5 cap.
     const maxDpr = typeof window !== 'undefined' && window.matchMedia('(pointer: coarse)').matches ? 1.25 : 1.5;
-    return (_jsxs(Canvas, { camera: { position: [50, 50, 50], fov: 50 }, className: `transition-colors duration-700 ${isDark ? 'bg-[#1f2433]' : 'bg-[#fafafa]'}`, dpr: [1, maxDpr], frameloop: "never", gl: ((props) => {
+    const showGpuFallback = !canMountViewer || rendererInitFailed;
+    // When we can't mount the GPU canvas, the SceneReadyTracker never mounts and
+    // the host editor would otherwise wait on its scene-readiness timeout. Signal
+    // readiness explicitly so the host can drop its loader immediately.
+    useEffect(() => {
+        if (showGpuFallback)
+            onSceneReadyChange?.(true);
+    }, [showGpuFallback, onSceneReadyChange]);
+    if (showGpuFallback) {
+        return _jsx(UnsupportedGpuViewerFallback, {});
+    }
+    return (_jsxs(Canvas, { camera: { position: [50, 50, 50], fov: 50 }, className: `transition-colors duration-700 ${transparentBackground ? 'bg-transparent' : isDark ? 'bg-[#1f2433]' : 'bg-[#fafafa]'}`, dpr: [1, maxDpr], frameloop: "never", gl: ((props) => {
             const canvas = props.canvas;
             const cached = canvas ? WEBGPU_RENDERER_CACHE.get(canvas) : undefined;
             if (cached)
                 return cached;
             const promise = (async () => {
                 try {
-                    const renderer = new THREE.WebGPURenderer(props);
+                    const renderer = new THREE.WebGPURenderer({ ...props, alpha: true });
                     renderer.toneMapping = THREE.ACESFilmicToneMapping;
                     renderer.toneMappingExposure = getSceneTheme(useViewer.getState().sceneTheme).toneMappingExposure;
                     await renderer.init();
@@ -249,6 +349,7 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
                     if (canvas)
                         WEBGPU_RENDERER_CACHE.delete(canvas);
                     console.error('[viewer] WebGPURenderer init failed', err);
+                    setRendererInitFailed(true);
                     throw err;
                 }
             })();
@@ -259,8 +360,8 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
             debounce: 100,
         }, shadows: {
             type: THREE.PCFShadowMap,
-            enabled: true,
-        }, children: [_jsx(FrameLimiter, { fps: 50 }), _jsx(ViewerCamera, {}), _jsx(GPUDeviceWatcher, {}), _jsx(ToneMappingExposure, {}), _jsx(SceneReadyTracker, { onSceneReadyChange: onSceneReadyChange, sceneReadyKey: sceneReadyKey }), _jsxs(ErrorBoundary, { fallback: null, scope: "viewer-scene", children: [_jsx(Lights, {}), useBvh ? (_jsx(SceneBvh, { children: _jsx(SceneRenderer, {}) })) : (_jsx(SceneRenderer, {})), _jsx(FloorElevationSystem, {}), _jsx(GeometrySystem, {}), _jsx(StairOpeningSystem, {}), _jsx(RegisteredSystems, {}), _jsx(PostProcessing, { hoverStyles: hoverStyles }), selectionManager === 'default' && _jsx(SelectionManager, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfMonitor, {}), children] })] }));
+            enabled: shadowsEnabled,
+        }, children: [_jsx(FrameLimiter, { fps: 50 }), _jsx(ViewerCamera, {}), _jsx(GPUDeviceWatcher, {}), _jsx(ToneMappingExposure, {}), _jsx(SceneReadyTracker, { onSceneReadyChange: onSceneReadyChange, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs }), _jsxs(ErrorBoundary, { fallback: null, scope: "viewer-scene", children: [_jsx(Lights, {}), useBvh ? (_jsx(SceneBvh, { children: _jsx(SceneRenderer, {}) })) : (_jsx(SceneRenderer, {})), _jsx(FloorElevationSystem, {}), _jsx(GeometrySystem, {}), _jsx(StairOpeningSystem, {}), _jsx(RegisteredSystems, {}), _jsx(PostProcessing, { disablePostFx: disablePostFx, hoverStyles: hoverStyles }), selectionManager === 'default' && _jsx(SelectionManager, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfMonitor, {}), children] })] }));
 });
 const DebugRenderer = () => {
     useFrame(({ gl, scene, camera }) => {

package/dist/components/viewer/lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/lights.tsx"],"names":[],"mappings":"AAqDA,wBAAgB,MAAM,gCA2NrB"}
+{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/lights.tsx"],"names":[],"mappings":"AA4EA,wBAAgB,MAAM,gCAgPrB"}

package/dist/components/viewer/lights.js

@@ -3,6 +3,7 @@ import { sceneRegistry } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useMemo, useRef } from 'react';
 import * as THREE from 'three/webgpu';
+import { SHADOW_ONLY_LAYER } from '../../lib/layers';
 import { getSceneTheme } from '../../lib/scene-themes';
 import useViewer from '../../store/use-viewer';
 // Diagnostic toggle: `?disable=shadows` skips the shadow-map render pass
@@ -12,10 +13,27 @@ const SHADOWS_DISABLED = typeof window !== 'undefined' &&
     new Set((new URLSearchParams(window.location.search).get('disable') ?? '')
         .split(',')
         .map((s) => s.trim())).has('shadows');
+// Diagnostic toggle: `?debug=shadowcamera` draws a CameraHelper for each
+// shadow camera so the building-fit frustum (and thus shadow texel density)
+// can be inspected while tuning margins/bias.
+const SHADOW_CAMERA_DEBUG = typeof window !== 'undefined' &&
+    new Set((new URLSearchParams(window.location.search).get('debug') ?? '')
+        .split(',')
+        .map((s) => s.trim())).has('shadowcamera');
 // Shadow darkness for the bright key lights (themes drive most lights past
-// intensity 1). The aesthetic prototype runs these near-black (≈1.0); this is a
-// deliberate middle ground — present, but not the heavy contact shadow there.
-const MAX_SHADOW_INTENSITY = 0.55;
+// intensity 1). Runs high so shadowed areas actually lose the sun's
+// contribution — the ambient/hemisphere/IBL stack provides the fill. The old
+// 0.55 clamp leaked 45% of the key light into shadow and flattened interiors;
+// 0.9 read too heavy in review.
+const MAX_SHADOW_INTENSITY = 0.75;
+// `normalBias` is measured in world units. The previous 0.3 moved shadow
+// lookups 30 cm off their surfaces, visibly detaching wall shadows at the
+// floor; 0.07 and below still acnes on the building-fit 1024 map (large
+// texels), so 0.08 is the smallest acne-free value at that resolution — even
+// with the depth bias at -0.0005 (which is itself needed: 0.08 alone still
+// showed faint acne at -0.0001).
+const SHADOW_DEPTH_BIAS = -0.0005;
+const SHADOW_NORMAL_BIAS = 0.08;
 // Shadow frustum framing. The frustum is fit to the BUILDING geometry (not the
 // camera): we union the bounds of all registered scene nodes, fit a sphere, and
 // size the directional light's ortho shadow camera to that sphere plus a margin.
@@ -54,6 +72,7 @@ export function Lights() {
     const boundsBox = useRef(new THREE.Box3()); // scratch: union AABB
     const boundsSphere = useRef(new THREE.Sphere()); // scratch: fitted sphere
     const lastBoundsTime = useRef(-1); // last refresh timestamp (-1 = never)
+    const shadowHelpers = useRef([]);
     const hemiRef = useRef(null);
     const ambientRef = useRef(null);
     const initialized = useRef(false);
@@ -129,6 +148,9 @@ export function Lights() {
                 // the <orthographicCamera attach="shadow-camera"> below.
                 const cam = light.shadow?.camera;
                 if (cam) {
+                    // Shadow-caster-only geometry (hidden roofs/levels in cutaway views)
+                    // is visible to the shadow pass alone — see lib/shadow-only.ts.
+                    cam.layers.enable(SHADOW_ONLY_LAYER);
                     cam.left = -size;
                     cam.right = size;
                     cam.top = size;
@@ -136,6 +158,15 @@ export function Lights() {
                     cam.near = near;
                     cam.far = far;
                     cam.updateProjectionMatrix();
+                    if (SHADOW_CAMERA_DEBUG) {
+                        let helper = shadowHelpers.current[index];
+                        if (!helper) {
+                            helper = new THREE.CameraHelper(cam);
+                            shadowHelpers.current[index] = helper;
+                            state.scene.add(helper);
+                        }
+                        helper.update();
+                    }
                 }
             }
         }
@@ -195,7 +226,7 @@ export function Lights() {
             ambientRef.current.color.lerp(targets.ambColor, dt);
         }
     });
-    return (_jsxs(_Fragment, { children: [theme.lights.map((light, index) => (_jsx("directionalLight", { castShadow: Boolean(light.castShadow) && !SHADOWS_DISABLED && shadows, position: light.position, ref: (ref) => {
+    return (_jsxs(_Fragment, { children: [theme.lights.map((light, index) => (_jsx("directionalLight", { castShadow: Boolean(light.castShadow) && !SHADOWS_DISABLED, position: light.position, ref: (ref) => {
                     lightRefs.current[index] = ref;
-                }, "shadow-bias": -0.002, "shadow-mapSize": [1024, 1024], "shadow-normalBias": 0.3, "shadow-radius": 1.5, children: light.castShadow && !SHADOWS_DISABLED && shadows ? (_jsx("orthographicCamera", { attach: "shadow-camera", bottom: -shadowCameraSize, far: 400, left: -shadowCameraSize, near: 1, ref: shadowCamera, right: shadowCameraSize, top: shadowCameraSize })) : null }, `${index}-${light.position.join(',')}`))), theme.hemi ? _jsx("hemisphereLight", { ref: hemiRef }) : null, _jsx("ambientLight", { ref: ambientRef })] }));
+                }, "shadow-bias": SHADOW_DEPTH_BIAS, "shadow-mapSize": [1024, 1024], "shadow-normalBias": SHADOW_NORMAL_BIAS, "shadow-radius": 2, children: light.castShadow && !SHADOWS_DISABLED ? (_jsx("orthographicCamera", { attach: "shadow-camera", bottom: -shadowCameraSize, far: 400, left: -shadowCameraSize, near: 1, ref: shadowCamera, right: shadowCameraSize, top: shadowCameraSize })) : null }, `${index}-${light.position.join(',')}`))), theme.hemi ? _jsx("hemisphereLight", { ref: hemiRef }) : null, _jsx("ambientLight", { ref: ambientRef })] }));
 }

package/dist/components/viewer/perf-monitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perf-monitor.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/perf-monitor.tsx"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW,mCAuIvB,CAAA"}
+{"version":3,"file":"perf-monitor.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/perf-monitor.tsx"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW,mCAsJvB,CAAA"}

package/dist/components/viewer/perf-monitor.js

@@ -14,6 +14,7 @@ export const PerfMonitor = () => {
         drawCalls: 0,
         triangles: 0,
         dirty: 0,
+        dirtyDetail: '',
         meshes: 0,
         lines: 0,
         sprites: 0,
@@ -57,7 +58,20 @@ export const PerfMonitor = () => {
             const drawCalls = Math.round(totalCalls / Math.max(1, frameCount.current));
             const triangles = totalTriangles / Math.max(1, frameCount.current);
             info.reset();
-            const dirty = useScene.getState().dirtyNodes.size;
+            const sceneState = useScene.getState();
+            const dirty = sceneState.dirtyNodes.size;
+            let dirtyDetail = '';
+            if (dirty > 0) {
+                const counts = new Map();
+                for (const id of sceneState.dirtyNodes) {
+                    const type = sceneState.nodes[id]?.type ?? 'missing';
+                    counts.set(type, (counts.get(type) ?? 0) + 1);
+                }
+                dirtyDetail = [...counts.entries()]
+                    .sort((a, b) => b[1] - a[1])
+                    .map(([type, count]) => `${count} ${type}`)
+                    .join(', ');
+            }
             // Count visible drawables by type so we can match scene contents
             // against the renderer's draw count and find hidden contributors.
             let meshes = 0;
@@ -99,6 +113,7 @@ export const PerfMonitor = () => {
                 drawCalls,
                 triangles,
                 dirty,
+                dirtyDetail,
                 meshes,
                 lines,
                 sprites,
@@ -122,7 +137,7 @@ export const PerfMonitor = () => {
 GPU    ${stats.gpuMs > 0 ? `${stats.gpuMs.toFixed(1)}ms (max ${stats.gpuMaxMs.toFixed(1)})` : '—'}
 DRAW   ${stats.drawCalls}
 TRI    ${(stats.triangles / 1000).toFixed(1)}k
-DIRTY  ${stats.dirty}
+DIRTY  ${stats.dirty}${stats.dirtyDetail ? ` (${stats.dirtyDetail})` : ''}
 MESH   ${stats.meshes}
 LINE   ${stats.lines}
 SPRITE ${stats.sprites}

package/dist/components/viewer/post-processing.d.ts

@@ -1,3 +1,7 @@
+export declare const GRADE_PARAMS: {
+    contrast: number;
+    saturation: number;
+};
 export declare const SSGI_PARAMS: {
     enabled: boolean;
     sliceCount: number;
@@ -22,8 +26,10 @@ export type HoverStyles = {
     default: HoverStyle;
 } & Record<string, HoverStyle>;
 export declare const DEFAULT_HOVER_STYLES: HoverStyles;
-declare const PostProcessingPasses: ({ hoverStyles, }: {
+declare const PostProcessingPasses: ({ hoverStyles, disablePostFx, }: {
     hoverStyles?: HoverStyles;
+    /** Host-controlled equivalent of `?disable=postFx` — see the Viewer prop. */
+    disablePostFx?: boolean;
 }) => null;
 export default PostProcessingPasses;
 //# sourceMappingURL=post-processing.d.ts.map

package/dist/components/viewer/post-processing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"post-processing.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/post-processing.tsx"],"names":[],"mappings":"AAgCA,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAavB,CAAA;AA0CD,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,UAAU,CAAA;CACpB,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;AAS9B,eAAO,MAAM,oBAAoB,EAAE,WAElC,CAAA;AAiBD,QAAA,MAAM,oBAAoB,GAAI,kBAE3B;IACD,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B,SAgdA,CAAA;AAED,eAAe,oBAAoB,CAAA"}
+{"version":3,"file":"post-processing.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/post-processing.tsx"],"names":[],"mappings":"AAwCA,eAAO,MAAM,YAAY;;;CAGxB,CAAA;AAGD,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAavB,CAAA;AA0DD,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,UAAU,CAAA;CACpB,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;AAS9B,eAAO,MAAM,oBAAoB,EAAE,WAElC,CAAA;AAiBD,QAAA,MAAM,oBAAoB,GAAI,iCAG3B;IACD,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,SAgnBA,CAAA;AAED,eAAe,oBAAoB,CAAA"}