@crystaldesign/real-time-viewer-next 26.11.0-beta.18

package/build/types/real-time-viewer-next/src/core/meshBVH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshBVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/meshBVH.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAwB,QAAQ,EAAE,MAAM,OAAO,CAAC;AAgD5D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAGtD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAMtC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAmB/C"}

package/build/types/real-time-viewer-next/src/core/meshBVH.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=meshBVH.test.d.ts.map

package/build/types/real-time-viewer-next/src/core/meshBVH.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshBVH.test.d.ts","sourceRoot":"","sources":["../../../../../src/core/meshBVH.test.ts"],"names":[],"mappings":""}

package/build/types/real-time-viewer-next/src/core/postprocessing/PostProcessingDynamicEffects.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { ResolvedEnvironmentConfig } from '../../types/environment';
+type Pp = ResolvedEnvironmentConfig['postProcessing'];
+/**
+ * Post passes that need scene lookups, store selection, or Drei texture loading.
+ */
+export declare function PostProcessingDynamicEffects({ pp }: {
+    pp: Pp;
+}): React.JSX.Element;
+export {};
+//# sourceMappingURL=PostProcessingDynamicEffects.d.ts.map

package/build/types/real-time-viewer-next/src/core/postprocessing/PostProcessingDynamicEffects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostProcessingDynamicEffects.d.ts","sourceRoot":"","sources":["../../../../../../src/core/postprocessing/PostProcessingDynamicEffects.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAKvC,OAAO,KAAK,EAA6B,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAKpG,KAAK,EAAE,GAAG,yBAAyB,CAAC,gBAAgB,CAAC,CAAC;AAuDtD;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,EAAE,EAAE;IAAE,EAAE,EAAE,EAAE,CAAA;CAAE,qBAiJ9D"}

package/build/types/real-time-viewer-next/src/core/postprocessing/PostProcessingStack.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { ResolvedEnvironmentConfig } from '../../types/environment';
+interface PostProcessingStackProps {
+    postProcessing: ResolvedEnvironmentConfig['postProcessing'];
+    /**
+     * When `true`, the heavy passes (SSAO, Bloom, DoF, autofocus, vignette, colour grading, tone
+     * mapping, …) are skipped while the composer itself stays mounted, leaving a minimal SMAA + MSAA
+     * chain for the 2D top-down view. Keeping the composer mounted across the toggle keeps the Outline
+     * hover pass stable. SMAA is forced on so the composer never carries an empty pass list, and it's
+     * mode-keyed so the screen pass re-inits on the toggle (see the `aaKeySuffix` comment). Driven by
+     * `ViewModeRuntime`.
+     */
+    disableHeavyEffects?: boolean;
+}
+/**
+ * Composes the per-frame post-processing graph (single pmndrs `EffectComposer`)
+ * from the resolved env's `postProcessing` block. An effect mounts when its
+ * config is present in `pp` (e.g. `pp.ssrEffect` truthy → `<SSR />`); the
+ * profile is the only signal that decides what runs. Switch profiles to change
+ * the cost envelope.
+ *
+ * Memoized: drei's `EffectComposer` rebuilds ALL passes whenever its `children` identity
+ * changes (every re-render), which has caused output-encode glitches around reused effect
+ * instances (see `aaKeySuffix`) — parent re-renders must not reach the composer.
+ */
+export declare const PostProcessingStack: React.NamedExoticComponent<PostProcessingStackProps>;
+export {};
+//# sourceMappingURL=PostProcessingStack.d.ts.map

package/build/types/real-time-viewer-next/src/core/postprocessing/PostProcessingStack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostProcessingStack.d.ts","sourceRoot":"","sources":["../../../../../../src/core/postprocessing/PostProcessingStack.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2F,MAAM,OAAO,CAAC;AAqBhH,OAAO,KAAK,EAAE,yBAAyB,EAA+B,MAAM,yBAAyB,CAAC;AAgDtG,UAAU,wBAAwB;IAChC,cAAc,EAAE,yBAAyB,CAAC,gBAAgB,CAAC,CAAC;IAC5D;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AA4CD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,sDAiO9B,CAAC"}

package/build/types/real-time-viewer-next/src/core/postprocessing/applyRendererToneMapping.d.ts

@@ -0,0 +1,10 @@
+/**
+ * pmndrs `postprocessing` stack: `ToneMapping` is a pass; avoid double tone-mapping on the renderer.
+ */
+export declare function applyRendererForPmndrsPostProcessing(gl: {
+    toneMapping: number;
+    toneMappingExposure: number;
+}, pp: {
+    exposure: number;
+}): void;
+//# sourceMappingURL=applyRendererToneMapping.d.ts.map

package/build/types/real-time-viewer-next/src/core/postprocessing/applyRendererToneMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyRendererToneMapping.d.ts","sourceRoot":"","sources":["../../../../../../src/core/postprocessing/applyRendererToneMapping.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAgB,oCAAoC,CAAC,EAAE,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAA;CAAE,EAAE,EAAE,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,QAGtI"}

package/build/types/real-time-viewer-next/src/core/postprocessing/index.d.ts

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

package/build/types/real-time-viewer-next/src/core/postprocessing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/core/postprocessing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/build/types/real-time-viewer-next/src/core/postprocessing/postProcessing.config.d.ts

@@ -0,0 +1,453 @@
+import { type ConfigInput, type ConfigResolved, type NumberField } from '../../config/descriptor';
+declare const SSAO_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    blendFunction: NumberField;
+    intensity: NumberField;
+    radius: NumberField;
+    samples: NumberField;
+    rings: NumberField;
+    /** World-space distance (meters in typical RTV scenes) at which AO fades out. */
+    worldDistanceThreshold: NumberField;
+    /** Falloff shaping for {@link worldDistanceThreshold}. */
+    worldDistanceFalloff: NumberField;
+    /** World-space proximity (meters) where contact / near-field AO is strongest. */
+    worldProximityThreshold: NumberField;
+    worldProximityFalloff: NumberField;
+    /** View-space / scaled distance thresholds (library-specific). */
+    distanceThreshold: NumberField;
+    distanceFalloff: NumberField;
+    rangeThreshold: NumberField;
+    rangeFalloff: NumberField;
+    minRadiusScale: NumberField;
+    distanceScaling: import("../../config/descriptor").BooleanField;
+    depthAwareUpsampling: import("../../config/descriptor").BooleanField;
+    /** Internal buffer scale vs full resolution (e.g. 0.5 = half-res SSAO). */
+    resolutionScale: NumberField;
+    luminanceInfluence: NumberField;
+    bias: NumberField;
+    fade: NumberField;
+    /** AO tint. */
+    color: import("../../config/descriptor").ColorField;
+}>;
+/** `BloomEffect` — `threshold` maps to `luminanceThreshold`. */
+declare const BLOOM_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    intensity: NumberField;
+    opacity: NumberField;
+    /** pmndrs docs default `luminanceThreshold` to 0.9; we match that. */
+    threshold: NumberField;
+    luminanceSmoothing: NumberField;
+    mipmapBlur: import("../../config/descriptor").BooleanField;
+    kernelSize: NumberField;
+    radius: NumberField;
+    blendFunction: NumberField;
+}>;
+/** `VignetteEffect` — `intensity` maps to `darkness`. */
+declare const VIGNETTE_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    intensity: NumberField;
+    opacity: NumberField;
+    offset: NumberField;
+    eskil: import("../../config/descriptor").BooleanField;
+    blendFunction: NumberField;
+}>;
+/**
+ * `DepthOfFieldEffect` — `focusDistance` and `focusRange` are **world units** (scene meters). When
+ * `targetPosition` is set the effect overwrites `focusDistance` each frame with the camera-to-target
+ * distance; `focusRange` stays the thickness of the sharp slab.
+ */
+declare const DEPTH_OF_FIELD_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    focusDistance: NumberField;
+    bokehScale: NumberField;
+    focusRange: NumberField;
+    blendFunction: NumberField;
+    resolutionScale: NumberField;
+    /**
+     * World-space focus target (pmndrs `DepthOfField` `target`). When set, overrides distance-only
+     * focus for that point; `null` falls back to `focusDistance` along the view ray. Split into three
+     * analyzer sliders behind a "Use world focus point" switch.
+     */
+    targetPosition: import("../../config/descriptor").ValueField<[number, number, number] | null>;
+}>;
+/** `ChromaticAberrationEffect` — when `offsetX`/`offsetY` are both 0, `intensity` drives the offset. */
+declare const CHROMATIC_ABERRATION_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    intensity: NumberField;
+    offsetX: NumberField;
+    offsetY: NumberField;
+    modulationOffset: NumberField;
+    radialModulation: import("../../config/descriptor").BooleanField;
+    blendFunction: NumberField;
+    opacity: NumberField;
+}>;
+/** Hue + brightness/contrast passes — `saturation` is Leva −50…50, scaled inside the stack. */
+declare const COLOR_GRADING_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    saturation: NumberField;
+    brightness: NumberField;
+    contrast: NumberField;
+    hue: NumberField;
+    hueSaturationOpacity: NumberField;
+    brightnessContrastOpacity: NumberField;
+    hueSaturationBlendFunction: NumberField;
+    brightnessContrastBlendFunction: NumberField;
+}>;
+/** `NoiseEffect` — `intensity` maps to `opacity`. */
+declare const NOISE_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    intensity: NumberField;
+    premultiply: import("../../config/descriptor").BooleanField;
+    blendFunction: NumberField;
+}>;
+declare const OUTLINE_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    /** Matches the `postprocessing` `OutlineEffect` default — `NORMAL` can composite to a black frame. */
+    blendFunction: NumberField;
+    edgeStrength: NumberField;
+    pulseSpeed: NumberField;
+    visibleEdgeColor: NumberField;
+    hiddenEdgeColor: NumberField;
+    resolutionScale: NumberField;
+    blur: import("../../config/descriptor").BooleanField;
+    xRay: import("../../config/descriptor").BooleanField;
+    kernelSize: NumberField;
+}>;
+/** pmndrs `SelectiveBloom` — selection from scene + store. */
+declare const SELECTIVE_BLOOM_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    blendFunction: NumberField;
+    intensity: NumberField;
+    threshold: NumberField;
+    luminanceSmoothing: NumberField;
+    mipmapBlur: import("../../config/descriptor").BooleanField;
+    kernelSize: NumberField;
+    inverted: import("../../config/descriptor").BooleanField;
+    ignoreBackground: import("../../config/descriptor").BooleanField;
+}>;
+/** pmndrs `GodRays` — `sunMeshName` must reference a `Mesh` or `Points` in the scene. */
+declare const GOD_RAYS_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    blendFunction: NumberField;
+    samples: NumberField;
+    density: NumberField;
+    decay: NumberField;
+    weight: NumberField;
+    exposure: NumberField;
+    clampMax: NumberField;
+    resolutionScale: NumberField;
+    blur: import("../../config/descriptor").BooleanField;
+    sunMeshName: import("../../config/descriptor").ValueField<string>;
+}>;
+/** pmndrs `Autofocus` — when enabled, use instead of stacking with `depthOfField` (the stack skips DoF). */
+declare const AUTOFOCUS_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    blendFunction: NumberField;
+    bokehScale: NumberField;
+    resolutionScale: NumberField;
+    mouse: import("../../config/descriptor").BooleanField;
+    smoothTime: NumberField;
+    debug: NumberField;
+}>;
+/** pmndrs `SSR` — subset; `USE_MRT` needs G-buffer support. */
+declare const SSR_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    temporalResolve: import("../../config/descriptor").BooleanField;
+    temporalResolveMix: NumberField;
+    intensity: NumberField;
+    maxRoughness: NumberField;
+    rayStep: NumberField;
+    maxDepth: NumberField;
+    thickness: NumberField;
+    ENABLE_BLUR: import("../../config/descriptor").BooleanField;
+    blurMix: NumberField;
+    USE_MRT: import("../../config/descriptor").BooleanField;
+    USE_ROUGHNESSMAP: import("../../config/descriptor").BooleanField;
+    USE_NORMALMAP: import("../../config/descriptor").BooleanField;
+}>;
+/** pmndrs `N8AO`. */
+declare const N8AO_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    aoRadius: NumberField;
+    distanceFalloff: NumberField;
+    intensity: NumberField;
+    quality: import("../../config/descriptor").EnumField<"high" | "low" | "medium" | "performance" | "ultra">;
+    halfRes: import("../../config/descriptor").BooleanField;
+    screenSpaceRadius: import("../../config/descriptor").BooleanField;
+}>;
+/** pmndrs `LUT` — 3D LUT loaded from URL. */
+declare const LUT_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    url: import("../../config/descriptor").ValueField<string>;
+    blendFunction: NumberField;
+    tetrahedralInterpolation: import("../../config/descriptor").BooleanField;
+}>;
+/** pmndrs `LensFlare` — simplified; the dirt texture is optional. */
+declare const SCREEN_LENS_FLARE_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    blendFunction: NumberField;
+    opacity: NumberField;
+    glareSize: NumberField;
+    flareSize: NumberField;
+    lensPosition: import("../../config/descriptor").TupleField<[number, number, number]>;
+    /**
+     * Anchor the flare far along the `lighting.sun` direction instead of at `lensPosition`, which is
+     * the only way a sun flare stays on the sun: the effect takes a world point, the sun is
+     * directional, and a hand-computed point silently detaches as soon as the sun angles change.
+     */
+    followSun: import("../../config/descriptor").BooleanField;
+    lensDirtUrl: import("../../config/descriptor").ValueField<string | null>;
+}>;
+/** Params for `ToneMappingEffect`'s adaptive (HDR) path. */
+declare const TONE_MAPPING_ADAPTIVE_FIELDS: import("../../config/descriptor").GroupDescriptor<{
+    resolution: NumberField;
+    maxLuminance: NumberField;
+    whitePoint: NumberField;
+    middleGrey: NumberField;
+    minLuminance: NumberField;
+    averageLuminance: NumberField;
+    adaptationRate: NumberField;
+}>;
+/**
+ * Post-processing config — the single source for its types, defaults, clamps, round-trip and
+ * analyzer inputs (see `config/descriptor.ts`). Drives `PostProcessingStack`.
+ *
+ * Every effect is a switchable block: `false` when off, fully filled when on. Tone-mapping defaults
+ * match EZ-Tree (`neutral` at exposure 2 keeps highlights and mid-tones close to their authored
+ * colors instead of crushing them like ACES).
+ */
+export declare const POST_PROCESSING_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    enabled: import("../../config/descriptor").BooleanField;
+    multisampling: NumberField;
+    bloom: import("../../config/descriptor").ToggleDescriptor<{
+        intensity: NumberField;
+        opacity: NumberField;
+        /** pmndrs docs default `luminanceThreshold` to 0.9; we match that. */
+        threshold: NumberField;
+        luminanceSmoothing: NumberField;
+        mipmapBlur: import("../../config/descriptor").BooleanField;
+        kernelSize: NumberField;
+        radius: NumberField;
+        blendFunction: NumberField;
+    }>;
+    vignette: import("../../config/descriptor").ToggleDescriptor<{
+        intensity: NumberField;
+        opacity: NumberField;
+        offset: NumberField;
+        eskil: import("../../config/descriptor").BooleanField;
+        blendFunction: NumberField;
+    }>;
+    depthOfField: import("../../config/descriptor").ToggleDescriptor<{
+        focusDistance: NumberField;
+        bokehScale: NumberField;
+        focusRange: NumberField;
+        blendFunction: NumberField;
+        resolutionScale: NumberField;
+        /**
+         * World-space focus target (pmndrs `DepthOfField` `target`). When set, overrides distance-only
+         * focus for that point; `null` falls back to `focusDistance` along the view ray. Split into three
+         * analyzer sliders behind a "Use world focus point" switch.
+         */
+        targetPosition: import("../../config/descriptor").ValueField<[number, number, number] | null>;
+    }>;
+    chromaticAberration: import("../../config/descriptor").ToggleDescriptor<{
+        intensity: NumberField;
+        offsetX: NumberField;
+        offsetY: NumberField;
+        modulationOffset: NumberField;
+        radialModulation: import("../../config/descriptor").BooleanField;
+        blendFunction: NumberField;
+        opacity: NumberField;
+    }>;
+    colorGrading: import("../../config/descriptor").ToggleDescriptor<{
+        saturation: NumberField;
+        brightness: NumberField;
+        contrast: NumberField;
+        hue: NumberField;
+        hueSaturationOpacity: NumberField;
+        brightnessContrastOpacity: NumberField;
+        hueSaturationBlendFunction: NumberField;
+        brightnessContrastBlendFunction: NumberField;
+    }>;
+    noise: import("../../config/descriptor").ToggleDescriptor<{
+        intensity: NumberField;
+        premultiply: import("../../config/descriptor").BooleanField;
+        blendFunction: NumberField;
+    }>;
+    outlineEffect: import("../../config/descriptor").ToggleDescriptor<{
+        /** Matches the `postprocessing` `OutlineEffect` default — `NORMAL` can composite to a black frame. */
+        blendFunction: NumberField;
+        edgeStrength: NumberField;
+        pulseSpeed: NumberField;
+        visibleEdgeColor: NumberField;
+        hiddenEdgeColor: NumberField;
+        resolutionScale: NumberField;
+        blur: import("../../config/descriptor").BooleanField;
+        xRay: import("../../config/descriptor").BooleanField;
+        kernelSize: NumberField;
+    }>;
+    outlineHoverEffect: import("../../config/descriptor").ToggleDescriptor<{
+        /** Matches the `postprocessing` `OutlineEffect` default — `NORMAL` can composite to a black frame. */
+        blendFunction: NumberField;
+        edgeStrength: NumberField;
+        pulseSpeed: NumberField;
+        visibleEdgeColor: NumberField;
+        hiddenEdgeColor: NumberField;
+        resolutionScale: NumberField;
+        blur: import("../../config/descriptor").BooleanField;
+        xRay: import("../../config/descriptor").BooleanField;
+        kernelSize: NumberField;
+    }>;
+    selectiveBloomEffect: import("../../config/descriptor").ToggleDescriptor<{
+        blendFunction: NumberField;
+        intensity: NumberField;
+        threshold: NumberField;
+        luminanceSmoothing: NumberField;
+        mipmapBlur: import("../../config/descriptor").BooleanField;
+        kernelSize: NumberField;
+        inverted: import("../../config/descriptor").BooleanField;
+        ignoreBackground: import("../../config/descriptor").BooleanField;
+    }>;
+    godRaysEffect: import("../../config/descriptor").ToggleDescriptor<{
+        blendFunction: NumberField;
+        samples: NumberField;
+        density: NumberField;
+        decay: NumberField;
+        weight: NumberField;
+        exposure: NumberField;
+        clampMax: NumberField;
+        resolutionScale: NumberField;
+        blur: import("../../config/descriptor").BooleanField;
+        sunMeshName: import("../../config/descriptor").ValueField<string>;
+    }>;
+    autofocusEffect: import("../../config/descriptor").ToggleDescriptor<{
+        blendFunction: NumberField;
+        bokehScale: NumberField;
+        resolutionScale: NumberField;
+        mouse: import("../../config/descriptor").BooleanField;
+        smoothTime: NumberField;
+        debug: NumberField;
+    }>;
+    ssrEffect: import("../../config/descriptor").ToggleDescriptor<{
+        temporalResolve: import("../../config/descriptor").BooleanField;
+        temporalResolveMix: NumberField;
+        intensity: NumberField;
+        maxRoughness: NumberField;
+        rayStep: NumberField;
+        maxDepth: NumberField;
+        thickness: NumberField;
+        ENABLE_BLUR: import("../../config/descriptor").BooleanField;
+        blurMix: NumberField;
+        USE_MRT: import("../../config/descriptor").BooleanField;
+        USE_ROUGHNESSMAP: import("../../config/descriptor").BooleanField;
+        USE_NORMALMAP: import("../../config/descriptor").BooleanField;
+    }>;
+    n8aoEffect: import("../../config/descriptor").ToggleDescriptor<{
+        aoRadius: NumberField;
+        distanceFalloff: NumberField;
+        intensity: NumberField;
+        quality: import("../../config/descriptor").EnumField<"high" | "low" | "medium" | "performance" | "ultra">;
+        halfRes: import("../../config/descriptor").BooleanField;
+        screenSpaceRadius: import("../../config/descriptor").BooleanField;
+    }>;
+    lutEffect: import("../../config/descriptor").ToggleDescriptor<{
+        url: import("../../config/descriptor").ValueField<string>;
+        blendFunction: NumberField;
+        tetrahedralInterpolation: import("../../config/descriptor").BooleanField;
+    }>;
+    screenLensFlare: import("../../config/descriptor").ToggleDescriptor<{
+        blendFunction: NumberField;
+        opacity: NumberField;
+        glareSize: NumberField;
+        flareSize: NumberField;
+        lensPosition: import("../../config/descriptor").TupleField<[number, number, number]>;
+        /**
+         * Anchor the flare far along the `lighting.sun` direction instead of at `lensPosition`, which is
+         * the only way a sun flare stays on the sun: the effect takes a world point, the sun is
+         * directional, and a hand-computed point silently detaches as soon as the sun angles change.
+         */
+        followSun: import("../../config/descriptor").BooleanField;
+        lensDirtUrl: import("../../config/descriptor").ValueField<string | null>;
+    }>;
+    toneMapping: import("../../config/descriptor").BooleanField;
+    toneMappingBlendFunction: NumberField;
+    toneMappingOpacity: NumberField;
+    toneMappingAdaptive: import("../../config/descriptor").ToggleDescriptor<{
+        resolution: NumberField;
+        maxLuminance: NumberField;
+        whitePoint: NumberField;
+        middleGrey: NumberField;
+        minLuminance: NumberField;
+        averageLuminance: NumberField;
+        adaptationRate: NumberField;
+    }>;
+    toneMappingMode: import("../../config/descriptor").EnumField<"linear" | "neutral" | "aces" | "reinhard" | "cineon">;
+    exposure: NumberField;
+    antiAliasMode: import("../../config/descriptor").EnumField<"none" | "smaa" | "fxaa" | "msaa-only">;
+    /** Screen-space AO (pmndrs `SSAO`) — the only effect that is on by default. */
+    ssao: import("../../config/descriptor").ToggleDescriptor<{
+        blendFunction: NumberField;
+        intensity: NumberField;
+        radius: NumberField;
+        samples: NumberField;
+        rings: NumberField;
+        /** World-space distance (meters in typical RTV scenes) at which AO fades out. */
+        worldDistanceThreshold: NumberField;
+        /** Falloff shaping for {@link worldDistanceThreshold}. */
+        worldDistanceFalloff: NumberField;
+        /** World-space proximity (meters) where contact / near-field AO is strongest. */
+        worldProximityThreshold: NumberField;
+        worldProximityFalloff: NumberField;
+        /** View-space / scaled distance thresholds (library-specific). */
+        distanceThreshold: NumberField;
+        distanceFalloff: NumberField;
+        rangeThreshold: NumberField;
+        rangeFalloff: NumberField;
+        minRadiusScale: NumberField;
+        distanceScaling: import("../../config/descriptor").BooleanField;
+        depthAwareUpsampling: import("../../config/descriptor").BooleanField;
+        /** Internal buffer scale vs full resolution (e.g. 0.5 = half-res SSAO). */
+        resolutionScale: NumberField;
+        luminanceInfluence: NumberField;
+        bias: NumberField;
+        fade: NumberField;
+        /** AO tint. */
+        color: import("../../config/descriptor").ColorField;
+    }>;
+    ssaoFine: import("../../config/descriptor").ToggleDescriptor<{
+        blendFunction: NumberField;
+        intensity: NumberField;
+        radius: NumberField;
+        samples: NumberField;
+        rings: NumberField;
+        /** World-space distance (meters in typical RTV scenes) at which AO fades out. */
+        worldDistanceThreshold: NumberField;
+        /** Falloff shaping for {@link worldDistanceThreshold}. */
+        worldDistanceFalloff: NumberField;
+        /** World-space proximity (meters) where contact / near-field AO is strongest. */
+        worldProximityThreshold: NumberField;
+        worldProximityFalloff: NumberField;
+        /** View-space / scaled distance thresholds (library-specific). */
+        distanceThreshold: NumberField;
+        distanceFalloff: NumberField;
+        rangeThreshold: NumberField;
+        rangeFalloff: NumberField;
+        minRadiusScale: NumberField;
+        distanceScaling: import("../../config/descriptor").BooleanField;
+        depthAwareUpsampling: import("../../config/descriptor").BooleanField;
+        /** Internal buffer scale vs full resolution (e.g. 0.5 = half-res SSAO). */
+        resolutionScale: NumberField;
+        luminanceInfluence: NumberField;
+        bias: NumberField;
+        fade: NumberField;
+        /** AO tint. */
+        color: import("../../config/descriptor").ColorField;
+    }>;
+}>;
+export type PostProcessingConfig = ConfigInput<typeof POST_PROCESSING_CONFIG>;
+export type ResolvedPostProcessingConfig = ConfigResolved<typeof POST_PROCESSING_CONFIG>;
+export type ToneMappingMode = ResolvedPostProcessingConfig['toneMappingMode'];
+export type AntiAliasMode = ResolvedPostProcessingConfig['antiAliasMode'];
+export type SSAOConfig = ConfigInput<typeof SSAO_FIELDS>;
+export type BloomEffectConfig = ConfigResolved<typeof BLOOM_FIELDS>;
+export type VignetteEffectConfig = ConfigResolved<typeof VIGNETTE_FIELDS>;
+export type DepthOfFieldEffectConfig = ConfigResolved<typeof DEPTH_OF_FIELD_FIELDS>;
+export type ChromaticAberrationEffectConfig = ConfigResolved<typeof CHROMATIC_ABERRATION_FIELDS>;
+export type ColorGradingEffectConfig = ConfigResolved<typeof COLOR_GRADING_FIELDS>;
+export type NoiseEffectConfig = ConfigResolved<typeof NOISE_FIELDS>;
+export type ToneMappingAdaptiveConfig = ConfigResolved<typeof TONE_MAPPING_ADAPTIVE_FIELDS>;
+export type OutlinePassConfig = ConfigResolved<typeof OUTLINE_FIELDS>;
+export type SelectiveBloomPassConfig = ConfigResolved<typeof SELECTIVE_BLOOM_FIELDS>;
+export type GodRaysPassConfig = ConfigResolved<typeof GOD_RAYS_FIELDS>;
+export type AutofocusPassConfig = ConfigResolved<typeof AUTOFOCUS_FIELDS>;
+export type SsrPassConfig = ConfigResolved<typeof SSR_FIELDS>;
+export type N8aoPassConfig = ConfigResolved<typeof N8AO_FIELDS>;
+export type LutPassConfig = ConfigResolved<typeof LUT_FIELDS>;
+export type ScreenLensFlarePassConfig = ConfigResolved<typeof SCREEN_LENS_FLARE_FIELDS>;
+export { DEPTH_OF_FIELD_FIELDS };
+//# sourceMappingURL=postProcessing.config.d.ts.map

package/build/types/real-time-viewer-next/src/core/postprocessing/postProcessing.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postProcessing.config.d.ts","sourceRoot":"","sources":["../../../../../../src/core/postprocessing/postProcessing.config.ts"],"names":[],"mappings":"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"}

package/build/types/real-time-viewer-next/src/core/postprocessing/postProcessing.config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=postProcessing.config.test.d.ts.map

package/build/types/real-time-viewer-next/src/core/postprocessing/postProcessing.config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postProcessing.config.test.d.ts","sourceRoot":"","sources":["../../../../../../src/core/postprocessing/postProcessing.config.test.ts"],"names":[],"mappings":""}

package/build/types/real-time-viewer-next/src/core/renderer.config.d.ts

@@ -0,0 +1,55 @@
+import { type ConfigInput, type ConfigResolved } from '../config/descriptor';
+/**
+ * Renderer-level knobs forwarded to the R3F `<Canvas>` (and a few that the RTV runtime applies
+ * imperatively — `frameloop`, `maxFps`) — the single source for its types, defaults, clamps,
+ * round-trip and analyzer inputs (see `config/descriptor.ts`).
+ *
+ * These are the highest-impact performance levers. Profile-author intent: `low` typically lowers
+ * `dpr` and/or caps FPS for static planner scenes; `high` keeps full native DPR with unlimited FPS.
+ */
+export declare const RENDERER_CONFIG: import("../config/descriptor").GroupDescriptor<{
+    /**
+     * DPR (device pixel ratio) clamp. Single number = hard cap; tuple `[min, max]` = bounded range
+     * (the renderer picks within it). Lowering DPR is the single biggest GPU win on retina displays.
+     * Examples: `[0.75, 1]` Low tier (aggressive downscale), `[1, 1.5]` Medium, `[1, 2]` full retina.
+     *
+     * Split into two sliders in the analyzer, so it carries no leva metadata of its own.
+     */
+    dpr: import("../config/descriptor").ValueField<number | [min: number, max: number]>;
+    /**
+     * GPU selection hint. On laptops with both integrated and discrete GPUs, `'high-performance'`
+     * forces the discrete card (better perf, worse battery), `'low-power'` prefers the integrated
+     * one (cooler, longer battery life).
+     */
+    powerPreference: import("../config/descriptor").EnumField<"default" | "high-performance" | "low-power">;
+    /**
+     * R3F frame-loop mode. `'always'` renders every frame; `'demand'` only when state changes
+     * (massive CPU/GPU savings on stationary scenes, but `useFrame` animations freeze); `'never'`
+     * only on explicit invalidation. Independent of `maxFps`: the cap throttles screen presents
+     * inside a `gl.render` wrapper, so the mode set here keeps applying (visibility handling may
+     * still switch to `'never'` while the tab is hidden — see `useFrameloopVisibility`).
+     */
+    frameloop: import("../config/descriptor").EnumField<"always" | "never" | "demand">;
+    /**
+     * FPS cap. `0` = unlimited. Any positive value throttles SCREEN PRESENTS by wrapping
+     * `gl.render` (see `useFrameloopVisibility`): default-framebuffer renders are skipped down to
+     * every Nth vsync, while off-screen renders (water sim, captures, composer passes) always pass
+     * through and `useFrame` keeps running at full display rate — animations stay correct in
+     * wall-clock time, only the visible refresh drops. The cheapest knob for "still animate, but
+     * don't pin the GPU" on low-tier devices.
+     */
+    maxFps: import("../config/descriptor").NumberField;
+    /**
+     * Resolution of three's transmission pass relative to the drawing buffer. Any material with
+     * `transmission > 0` (glass, refractive water) makes three render the whole opaque scene once
+     * more into an extra full-resolution HalfFloat MSAA target with mipmaps — on an iPad at DPR 2
+     * that alone is ~200 MB. `0.5` quarters it at the cost of a slight blur behind transmissive
+     * surfaces.
+     */
+    transmissionResolutionScale: import("../config/descriptor").NumberField;
+    /** GLSL precision qualifier forwarded to the WebGL renderer. `'mediump'` is cheaper on mobile. */
+    precision: import("../config/descriptor").EnumField<"highp" | "mediump" | "lowp">;
+}>;
+export type RendererConfig = ConfigInput<typeof RENDERER_CONFIG>;
+export type ResolvedRendererConfig = ConfigResolved<typeof RENDERER_CONFIG>;
+//# sourceMappingURL=renderer.config.d.ts.map

package/build/types/real-time-viewer-next/src/core/renderer.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.config.d.ts","sourceRoot":"","sources":["../../../../../src/core/renderer.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEpF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;OAMG;;IAEH;;;;OAIG;;IAaH;;;;;;OAMG;;IASH;;;;;;;OAOG;;IAcH;;;;;;OAMG;;IAWH,kGAAkG;;EASlG,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,eAAe,CAAC,CAAC;AACjE,MAAM,MAAM,sBAAsB,GAAG,cAAc,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/build/types/real-time-viewer-next/src/core/renderer.config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=renderer.config.test.d.ts.map

package/build/types/real-time-viewer-next/src/core/renderer.config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.config.test.d.ts","sourceRoot":"","sources":["../../../../../src/core/renderer.config.test.ts"],"names":[],"mappings":""}

package/build/types/real-time-viewer-next/src/core/shadows/SceneShadowSystem.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+/**
+ * Shadow system orchestrator + sun light owner.
+ *
+ * The sun directional light lives here — not in `LightingRig` — so all shadow
+ * concerns (camera fit, autoUpdate gating, the `castShadow` gate) sit together
+ * with the dirty-flag plumbing. The light still renders whenever
+ * `lighting.sun.enabled` is true, even when `shadows.enabled` is false; only
+ * the `castShadow` flag toggles.
+ *
+ * Re-bakes ride the single `shadowsVersion` channel: `useShadowDirty` feeds
+ * store facts into it, the lights consume it (`useShadowRebake`).
+ *
+ * No catcher plane is mounted. Shadows fall on whatever scene mesh already
+ * has `receiveShadow=true` (per `shadowRegistry`).
+ */
+export declare function SceneShadowSystem(): React.JSX.Element | null;
+//# sourceMappingURL=SceneShadowSystem.d.ts.map

package/build/types/real-time-viewer-next/src/core/shadows/SceneShadowSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneShadowSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/core/shadows/SceneShadowSystem.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAqDzC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,6BA4ChC"}