@pascal-app/viewer 1.0.6 → 1.0.7

package/dist/index.js

@@ -10,8 +10,12 @@ export { ErrorBoundary } from './components/error-boundary';
 // `@pascal-app/nodes/<kind>/renderer.tsx` and are loaded by the registry
 // — no per-kind re-exports needed.
 export { NodeRenderer } from './components/renderers/node-renderer';
+// The generic renderer of a kind that ships `def.geometry`, for a kind's renderer that draws
+// something beside its built group.
+export { ParametricNodeRenderer } from './components/renderers/parametric-node-renderer';
 export { default as Viewer, pendingSceneBuildCount, } from './components/viewer';
 export { default as BVHEcctrl, } from './components/viewer/bvh-ecctrl';
+export { DroneController, } from './components/viewer/drone-controller';
 export { buildGlbInteractiveItems, GlbInteractive, } from './components/viewer/glb-interactive';
 export { buildGlbReferenceNodes, buildGlbReplaceNodes, } from './components/viewer/glb-reference-nodes';
 export { GlbScene, resolveGlbPick, } from './components/viewer/glb-scene';
@@ -20,6 +24,7 @@ export { DEFAULT_HOVER_STYLES, SSGI_PARAMS, } from './components/viewer/post-pro
 export { SceneAtmosphere, useSceneAtmosphere, } from './components/viewer/scene-atmosphere';
 export { SceneEnvironment } from './components/viewer/scene-environment';
 export { claimSceneGround, SceneGroundReplacement, useSceneGroundReplacement, } from './components/viewer/scene-ground-replacement';
+export { SelectionCallout, } from './components/viewer/selection-callout';
 export { applyWalkthroughCameraClipping } from './components/viewer/viewer-camera';
 export { isViewerPresentationTextureBorrowed, markViewerPresentationTextureBorrowed, registerViewerPresentation, ViewerPresentations, viewerPresentationRegistry, } from './components/viewer/viewer-presentations';
 export { useAssetUrl } from './hooks/use-asset-url';
@@ -33,7 +38,14 @@ export { applyWorldScaleBoxUVs } from './lib/box-uv';
 // geometry subtracts pieces against their host. Lives in viewer
 // because three-bvh-csg / three-mesh-bvh are viewer-only deps.
 export { ADDITION, Brush, computeGeometryBoundsTree, csgEvaluator, csgGeometry, csgMaterials, Evaluator, ensureRenderableGeometryAttributes, INTERSECTION, prepareBrushForCSG, SUBTRACTION, } from './lib/csg-utils';
+export { createDaylightGroundMaterial, DAYLIGHT_GROUND, DAYLIGHT_PARCEL, daylightGroundColor, } from './lib/daylight/ground';
+export { requestDeviceLocation, resolveLocation, } from './lib/daylight/location';
+export { isDaylightAtmosphere } from './lib/daylight/look';
+export { WEATHER_COVER } from './lib/daylight/sky';
+export { presetInstant, skyPhase, solarClockInstant, solarClockMinutes, solarPosition, sunEvents, } from './lib/daylight/solar';
 export { disposeObject3DResources } from './lib/dispose-object3d';
+export { createDroneInput, DRONE_SLOW_MULTIPLIER, seedDroneLook, stepDroneFlight, turnFirstPersonLook, } from './lib/drone-flight';
+export { markHighlight, tintEmissive } from './lib/editor-highlight';
 export { BLOCK_MASONRY, concreteMaterial, masonryMaterial, STRUCTURE_COLORS, } from './lib/foundation-materials';
 export { preserveGltfUnlit } from './lib/gltf-unlit';
 export { PERF_OVERLAY_ENABLED } from './lib/gpu-perf';
@@ -61,16 +73,16 @@ export { createSceneSupportHeightSampler } from './lib/scene-support-height';
 export { getSceneTheme, SCENE_THEME_IDS, SCENE_THEMES, } from './lib/scene-themes';
 export { hideFromScene, showInScene, temporarilyShowPresentation, temporarilyShowShadowOnly, } from './lib/scene-visibility';
 export { SCRIPTED_MODEL_FLAG } from './lib/scripted-opening';
-export { SITE_FOUNDATION, SITE_GROUND, siteFoundation, siteGround, siteSurfaces, temporarilyVeilGround, } from './lib/site-surfaces';
+export { SITE_GROUND, siteGround, siteSurfaces, temporarilyVeilGround, } from './lib/site-surfaces';
 export { createPlainSnapshotPipeline, createSnapshotPipeline, SNAPSHOT_MAX_EDGE, SNAPSHOT_MIME, SNAPSHOT_QUALITY, THUMBNAIL_HEIGHT, THUMBNAIL_WIDTH, } from './lib/snapshot-pipeline';
 export { buildTerrainPerimeterFillGeometry, } from './lib/terrain-perimeter-fill';
 export { getPascalTextureRef, stampPascalTextureRef, textureMapForSlot, } from './lib/texture-reference';
 export { packNormalToRGB, unpackRGBToNormal } from './lib/tsl-compat';
-export { AMBIANCE_SECONDS, ambianceNow, ambianceTarget, easeAmbiance, eyeUnderTheGround, FADE_SECONDS, groundHoleOpenNode, groundHoleOpenNow, stepAmbianceProgress, temporarilyWithoutAmbiance, UNDERGROUND_RIM, UNDERGROUND_RING, undergroundAmbianceNode, } from './lib/underground-ambiance';
+export { AMBIANCE_SECONDS, ambianceNow, ambianceTarget, easeAmbiance, eyeUnderTheGround, FADE_SECONDS, groundHoleOpenNode, groundHoleOpenNow, stepAmbianceProgress, temporarilyWithoutAmbiance, UNDERGROUND_RIM, undergroundAmbianceNode, } from './lib/underground-ambiance';
 export { createZoneShape, createZoneWallGeometry } from './lib/zone-geometry';
 export { catalogLightSource, useItemLightPool } from './store/use-item-light-pool';
-export { anyGroundVeiled, applyCountryUnitDefault, DEFAULT_UNDERGROUND_LOOK, default as useViewer, groundVeiled, siteGroundShown, } from './store/use-viewer';
-export { CEILING_REGION_MESH, CeilingSystem, } from './systems/ceiling/ceiling-system';
+export { applyCountryUnitDefault, DEFAULT_UNDERGROUND_LOOK, default as useViewer, groundVeiled, siteGroundShown, } from './store/use-viewer';
+export { CEILING_CAP_MESH, CEILING_REGION_MESH, CeilingSystem, } from './systems/ceiling/ceiling-system';
 export { createColumnBoxGeometry, createColumnCylinderGeometry, createColumnSphereGeometry, createColumnTorusGeometry, } from './systems/column/column-geometry';
 export { ConstructionReveal, emitRevealPuff, getRetractTurn, getRevealPlanSpeed, getRevealPlanState, getRevealTurn, isNodeRevealing, isRevealAssembling, retractNodes, revealChangedNodeIds, revealClockMs, revealMotionOff, seatLiftedNow, setRevealPreroll, startConstructionReveal, subscribeRevealAssembling, subscribeRevealEvents, subscribeRevealPhases, subscribeRevealTicks, useRevealPending, useRevealPlanActive, useRevealWaiting, } from './systems/construction-reveal/construction-reveal';
 export { DoorAnimationSystem } from './systems/door/door-animation-system';
@@ -83,20 +95,23 @@ export { ElevatorInteractionSystem } from './systems/elevator/elevator-interacti
 export { FloorElevationSystem } from './systems/floor-elevation/floor-elevation-system';
 export { GuideSystem } from './systems/guide/guide-system';
 export { InteractiveSystem } from './systems/interactive/interactive-system';
+export { openingSettled, proceduralSettled } from './systems/interactive/opening-settled';
 export { ScriptedClips, useClipActions, } from './systems/interactive/scripted-clips';
 // Item systems for the registry-driven item definition. ItemSystem
 // applies attachTo-driven transforms each frame; ItemLightSystem
 // manages item-mounted light sources.
 export { ItemSystem } from './systems/item/item-system';
 export { ItemLightSystem } from './systems/item-light/item-light-system';
+export { itemLightsForCapture } from './systems/item-light/pooled-lights';
 export { LevelSystem } from './systems/level/level-system';
 export { EXPLODED_GAP, getLevelPresentationY, presentLevelsForCapture, snapLevelsToTruePositions, } from './systems/level/level-utils';
-export { getRoofMaterialArray, levelWallCladdingRef } from './systems/roof/roof-materials';
+export { ROOF_GABLE_LEFT_MATERIAL_INDEX, ROOF_GABLE_RIGHT_MATERIAL_INDEX, ROOF_HEEL_MATERIAL_INDEX, ROOF_RENDER_MATERIAL_COUNT, } from './systems/roof/roof-material-slots';
+export { getRoofMaterialArray, levelWallCladdingRef, levelWallFaceRef, } from './systems/roof/roof-materials';
 // Generic roof-segment primitives. Kinds that compose CSG against
 // the roof shell (chimney's self-trim, dormer's virtual-segment cut)
 // read these through the public surface. No kind-specific helpers
 // belong here — those live in `@pascal-app/nodes/<kind>/`.
-export { clipDirectRoofGeometryAgainstSiblings, clipGeometryBySegmentTrim, generateRoofSegmentGeometry, getPendingRoofMergeCount, getRoofOuterSurfaceFrameAtPoint, getRoofSegmentBrushes, mapRoofGroupMaterialIndex, ROOF_MATERIAL_SLOT_COUNT, RoofSystem, remapRoofShellFaces, roofCsgDummyMats, } from './systems/roof/roof-system';
+export { clipDirectRoofGeometryAgainstSiblings, clipGeometryBySegmentTrim, generateRoofSegmentGeometry, getPendingRoofMergeCount, getRoofOuterSurfaceFrameAtPoint, getRoofSegmentBrushes, mapRoofGroupMaterialIndex, ROOF_MATERIAL_SLOT_COUNT, RoofSystem, remapRoofShellFaces, roofCsgDummyMats, splitRoofWallBandFaces, } from './systems/roof/roof-system';
 export { ScanSystem } from './systems/scan/scan-system';
 // Pure slab geometry generator — composed into the registry-driven slab
 // definition's `def.geometry` in `@pascal-app/nodes`.
@@ -116,7 +131,8 @@ export { getMaterialsForWall, getVisibleWallMaterials, } from './systems/wall/wa
 // 800+ lines of CSG / mitering logic during Phase 3. These exports are
 // removed in Phase 6 when the legacy mount points are deleted.
 export { drainRebuiltWalls, generateExtrudedWall, getPendingWallRebuildCount, isWallInitialBuildActive, runWallBuildFrame, WallSystem, } from './systems/wall/wall-system';
-export { poseWindowMovingParts, WindowAnimationSystem, } from './systems/window/window-animation-system';
+export { advanceWindowAnimations, poseWindowMovingParts, WindowAnimationSystem, } from './systems/window/window-animation-system';
+export { restoreWindowRollerShutter } from './systems/window/window-roller-shutter';
 export { buildWindowPreviewMesh, WindowSystem } from './systems/window/window-system';
 export { ZoneSystem } from './systems/zone/zone-system';
 export { useImmersiveXRPresentation } from './xr/presentation-context';

package/dist/lib/daylight/ground.d.ts

@@ -0,0 +1,21 @@
+import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+/** Neutral ground of the colored appearance, and the slightly fresher parcel inside the site. */
+export declare const DAYLIGHT_GROUND = "#a1a1a1";
+export declare const DAYLIGHT_PARCEL = "#afaeaa";
+/**
+ * The ground around the parcel: faint squares that stay a few pixels wide at every distance (a
+ * mip-like ladder of square sizes, so no shimmer towards the horizon) over long diagonal bands.
+ * World-anchored; the horizon blend comes from the atmosphere's fog.
+ */
+export declare function daylightGroundColor(base?: any): any;
+/**
+ * A matte daylight ground material: Standard (lit by the sky environment) in rendered shading,
+ * Lambert in solid shading, where every surface is Lambert and the sky comes as a hemisphere light.
+ * With `horizon` (the atmosphere's horizon radiance), the lit ground blends into the sky with
+ * horizontal distance (250 m → 2.6 km) — on the lit output, so the lighting can't band it.
+ */
+export declare function createDaylightGroundMaterial(solid: boolean, options?: {
+    color?: string;
+    horizon?: (direction: any) => any;
+}): MeshLambertNodeMaterial | MeshStandardNodeMaterial;
+//# sourceMappingURL=ground.d.ts.map

package/dist/lib/daylight/ground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/ground.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAA;AAEhF,iGAAiG;AACjG,eAAO,MAAM,eAAe,YAAY,CAAA;AACxC,eAAO,MAAM,eAAe,YAAY,CAAA;AAKxC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,GAA4B,GAAG,GAAG,CAc3E;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,EACd,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,KAAK,GAAG,CAAA;CAAO,GAClE,uBAAuB,GAAG,wBAAwB,CAgBpD"}

package/dist/lib/daylight/ground.js

@@ -0,0 +1,53 @@
+import { cameraPosition, clamp, color, exp2, floor, fract, fwidth, length, max, mix, normalize, output, positionWorld, sin, smoothstep, vec2, vec4, } from 'three/tsl';
+import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+/** Neutral ground of the colored appearance, and the slightly fresher parcel inside the site. */
+export const DAYLIGHT_GROUND = '#a1a1a1';
+export const DAYLIGHT_PARCEL = '#afaeaa';
+/** Horizontal distance (m) over which the ground fades into the horizon sky. */
+const HORIZON_FADE_NEAR = 250;
+const HORIZON_FADE_FAR = 2600;
+/**
+ * The ground around the parcel: faint squares that stay a few pixels wide at every distance (a
+ * mip-like ladder of square sizes, so no shimmer towards the horizon) over long diagonal bands.
+ * World-anchored; the horizon blend comes from the atmosphere's fog.
+ */
+export function daylightGroundColor(base = color(DAYLIGHT_GROUND)) {
+    const p = positionWorld.xz;
+    const texel = max(fwidth(p.x), fwidth(p.y));
+    const lod = clamp(texel.mul(1.7).mul(4).max(1e-6).log2(), 0, 8);
+    const l0 = lod.floor();
+    const squares = (level) => {
+        const scale = vec2(1.7).div(exp2(level));
+        // fract(sin) hash: three's `hash` casts to uint, which collapses every negative cell to one value.
+        const cell = floor(p.mul(scale)).add(vec2(level.mul(37), level.mul(11)));
+        return fract(sin(cell.dot(vec2(12.9898, 78.233))).mul(43758.5453)).sub(0.5);
+    };
+    const noise = mix(squares(l0), squares(l0.add(1)), lod.sub(l0)).mul(0.06);
+    const bands = sin(p.x.mul(0.31).add(p.y.mul(0.17))).mul(0.02);
+    return base.mul(noise.add(bands).add(1));
+}
+/**
+ * A matte daylight ground material: Standard (lit by the sky environment) in rendered shading,
+ * Lambert in solid shading, where every surface is Lambert and the sky comes as a hemisphere light.
+ * With `horizon` (the atmosphere's horizon radiance), the lit ground blends into the sky with
+ * horizontal distance (250 m → 2.6 km) — on the lit output, so the lighting can't band it.
+ */
+export function createDaylightGroundMaterial(solid, options = {}) {
+    const material = solid
+        ? new MeshLambertNodeMaterial()
+        : new MeshStandardNodeMaterial({ roughness: 0.95, metalness: 0 });
+    // The grounds skip the room system (the dilated room map would light a strip of lawn); they
+    // still receive the window spill and exterior lamps at night.
+    material.userData.noRooms = true;
+    if (options.color)
+        material.color.set(options.color);
+    else
+        material.colorNode = daylightGroundColor();
+    if (options.horizon) {
+        const d = positionWorld.sub(cameraPosition);
+        const fade = smoothstep(HORIZON_FADE_NEAR, HORIZON_FADE_FAR, length(d.xz));
+        material.fog = false;
+        material.outputNode = vec4(mix(output.rgb, options.horizon(normalize(d)), fade), output.a);
+    }
+    return material;
+}

package/dist/lib/daylight/location.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Where the sun is computed for. In order: the site's own geocoded point, a device location the
+ * user granted (cached by the host), a coarse guess from the browser's timezone, a mid-latitude
+ * default. Never prompts by itself: requesting the device location is a user action.
+ */
+export type LatLng = {
+    lat: number;
+    lng: number;
+};
+export type LocationSource = 'site' | 'device' | 'timezone' | 'default';
+type SiteLike = {
+    parcel?: {
+        originLngLat?: readonly [number, number] | null;
+    } | null;
+    dossier?: {
+        point?: {
+            lat?: number;
+            lng?: number;
+        } | null;
+    } | null;
+};
+export declare function siteLocation(site: SiteLike | null | undefined): LatLng | null;
+export declare const DEFAULT_LOCATION: LatLng;
+export declare function timezoneLocation(timeZone?: string): LatLng | null;
+export declare function resolveLocation(site: SiteLike | null | undefined, device: LatLng | null | undefined): {
+    location: LatLng;
+    source: LocationSource;
+};
+/** Ask the browser for the device position (call from a user gesture). */
+export declare function requestDeviceLocation(): Promise<LatLng>;
+export {};
+//# sourceMappingURL=location.d.ts.map

package/dist/lib/daylight/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/location.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AACjD,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAA;AAEvE,KAAK,QAAQ,GAAG;IACd,MAAM,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAA;IACnE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE;YAAE,GAAG,CAAC,EAAE,MAAM,CAAC;YAAC,GAAG,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAA;CACnE,CAAA;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAQ7E;AA6BD,eAAO,MAAM,gBAAgB,EAAE,MAAmC,CAAA;AAElE,wBAAgB,gBAAgB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUjE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EACjC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,cAAc,CAAA;CAAE,CAO9C;AAED,0EAA0E;AAC1E,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,MAAM,CAAC,CAYvD"}

package/dist/lib/daylight/location.js

@@ -0,0 +1,74 @@
+/**
+ * Where the sun is computed for. In order: the site's own geocoded point, a device location the
+ * user granted (cached by the host), a coarse guess from the browser's timezone, a mid-latitude
+ * default. Never prompts by itself: requesting the device location is a user action.
+ */
+export function siteLocation(site) {
+    const origin = site?.parcel?.originLngLat;
+    if (origin && Number.isFinite(origin[0]) && Number.isFinite(origin[1]))
+        return { lat: origin[1], lng: origin[0] };
+    const point = site?.dossier?.point;
+    if (point && Number.isFinite(point.lat) && Number.isFinite(point.lng))
+        return { lat: point.lat, lng: point.lng };
+    return null;
+}
+/** A representative city per common IANA zone — only to pick a plausible latitude/longitude. */
+const ZONE_POINTS = {
+    'America/New_York': { lat: 40.71, lng: -74.0 },
+    'America/Chicago': { lat: 41.88, lng: -87.63 },
+    'America/Denver': { lat: 39.74, lng: -104.99 },
+    'America/Phoenix': { lat: 33.45, lng: -112.07 },
+    'America/Los_Angeles': { lat: 34.05, lng: -118.24 },
+    'America/Toronto': { lat: 43.65, lng: -79.38 },
+    'America/Vancouver': { lat: 49.28, lng: -123.12 },
+    'America/Mexico_City': { lat: 19.43, lng: -99.13 },
+    'America/Sao_Paulo': { lat: -23.55, lng: -46.63 },
+    'Europe/London': { lat: 51.51, lng: -0.13 },
+    'Europe/Paris': { lat: 48.86, lng: 2.35 },
+    'Europe/Berlin': { lat: 52.52, lng: 13.4 },
+    'Europe/Madrid': { lat: 40.42, lng: -3.7 },
+    'Europe/Rome': { lat: 41.9, lng: 12.5 },
+    'Europe/Amsterdam': { lat: 52.37, lng: 4.9 },
+    'Europe/Stockholm': { lat: 59.33, lng: 18.07 },
+    'Asia/Tokyo': { lat: 35.68, lng: 139.69 },
+    'Asia/Shanghai': { lat: 31.23, lng: 121.47 },
+    'Asia/Singapore': { lat: 1.35, lng: 103.82 },
+    'Asia/Dubai': { lat: 25.2, lng: 55.27 },
+    'Asia/Kolkata': { lat: 19.08, lng: 72.88 },
+    'Australia/Sydney': { lat: -33.87, lng: 151.21 },
+    'Pacific/Auckland': { lat: -36.85, lng: 174.76 },
+};
+export const DEFAULT_LOCATION = { lat: 40.71, lng: -74.0 };
+export function timezoneLocation(timeZone) {
+    let zone = timeZone;
+    if (!zone) {
+        try {
+            zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        }
+        catch {
+            return null;
+        }
+    }
+    return (zone && ZONE_POINTS[zone]) || null;
+}
+export function resolveLocation(site, device) {
+    const fromSite = siteLocation(site);
+    if (fromSite)
+        return { location: fromSite, source: 'site' };
+    if (device)
+        return { location: device, source: 'device' };
+    const fromZone = timezoneLocation();
+    if (fromZone)
+        return { location: fromZone, source: 'timezone' };
+    return { location: DEFAULT_LOCATION, source: 'default' };
+}
+/** Ask the browser for the device position (call from a user gesture). */
+export function requestDeviceLocation() {
+    return new Promise((resolve, reject) => {
+        if (typeof navigator === 'undefined' || !navigator.geolocation) {
+            reject(new Error('Geolocation is unavailable'));
+            return;
+        }
+        navigator.geolocation.getCurrentPosition((position) => resolve({ lat: position.coords.latitude, lng: position.coords.longitude }), (error) => reject(error), { enableHighAccuracy: false, maximumAge: 24 * 3_600_000, timeout: 10_000 });
+    });
+}

package/dist/lib/daylight/look.d.ts

@@ -0,0 +1,33 @@
+import type { Vector3 } from 'three';
+import type { SceneAtmosphereSource } from '../../components/viewer/scene-atmosphere';
+/** Daylight-specific outputs the post-processing reads (white balance). */
+export type DaylightAtmosphereSource = SceneAtmosphereSource & {
+    /** Linear RGB gains: eye-like partial chromatic adaptation to the current illuminant. */
+    whiteBalance: Vector3;
+    /** The key light's shadow (the sun, or the moon at night): map size per quality tier. */
+    shadow: {
+        mapSize: number;
+        bias: number;
+        normalBias: number;
+        radius: number;
+    };
+    /** Sun elevation in degrees (negative at night). */
+    elevation: number;
+};
+export declare function isDaylightAtmosphere(source: unknown): source is DaylightAtmosphereSource;
+/** The colored appearance's grade, vignette and bloom (viewport and snapshots alike). */
+export declare const DAYLIGHT_GRADE: {
+    contrast: number;
+    saturation: number;
+    vignette: number;
+};
+export declare const DAYLIGHT_BLOOM: {
+    strength: number;
+    radius: number;
+    softKnee: number;
+};
+/** The daylight look ignores the scene theme: its ink edges are always the light-backdrop ink. */
+export declare const DAYLIGHT_INK_BACKDROP = "#d4d8dc";
+/** Scene-referred daylight grade: white balance, contrast around mid-grey, saturation. */
+export declare function daylightGradeRgb(rgb: any, whiteBalance: any): any;
+//# sourceMappingURL=look.d.ts.map

package/dist/lib/daylight/look.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"look.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/look.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAEpC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAA;AAErF,2EAA2E;AAC3E,MAAM,MAAM,wBAAwB,GAAG,qBAAqB,GAAG;IAC7D,yFAAyF;IACzF,YAAY,EAAE,OAAO,CAAA;IACrB,yFAAyF;IACzF,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7E,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,wBAAwB,CAExF;AAED,yFAAyF;AACzF,eAAO,MAAM,cAAc;IAAK,QAAQ;IAAQ,UAAU;IAAQ,QAAQ;CAAQ,CAAA;AAClF,eAAO,MAAM,cAAc;IAAK,QAAQ;IAAQ,MAAM;IAAQ,QAAQ;CAAO,CAAA;AAC7E,kGAAkG;AAClG,eAAO,MAAM,qBAAqB,YAAY,CAAA;AAE9C,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,GAAG,GAAG,CAKjE"}

package/dist/lib/daylight/look.js

@@ -0,0 +1,13 @@
+import { saturation, vec3 } from 'three/tsl';
+export function isDaylightAtmosphere(source) {
+    return Boolean(source && source.whiteBalance);
+}
+/** The colored appearance's grade, vignette and bloom (viewport and snapshots alike). */
+export const DAYLIGHT_GRADE = { contrast: 1.06, saturation: 1.06, vignette: 0.12 };
+export const DAYLIGHT_BLOOM = { strength: 0.12, radius: 0.18, softKnee: 0.4 };
+/** The daylight look ignores the scene theme: its ink edges are always the light-backdrop ink. */
+export const DAYLIGHT_INK_BACKDROP = '#d4d8dc';
+/** Scene-referred daylight grade: white balance, contrast around mid-grey, saturation. */
+export function daylightGradeRgb(rgb, whiteBalance) {
+    return saturation(rgb.max(0).mul(whiteBalance).div(0.18).pow(vec3(DAYLIGHT_GRADE.contrast)).mul(0.18), DAYLIGHT_GRADE.saturation);
+}

package/dist/lib/daylight/material-hooks.d.ts

@@ -0,0 +1,2 @@
+export declare function installDaylightMaterialHooks(): void;
+//# sourceMappingURL=material-hooks.d.ts.map

package/dist/lib/daylight/material-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material-hooks.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/material-hooks.ts"],"names":[],"mappings":"AAmIA,wBAAgB,4BAA4B,IAAI,IAAI,CA4FnD"}

package/dist/lib/daylight/material-hooks.js

@@ -0,0 +1,150 @@
+import { abs, cameraPosition, clamp, diffuseColor, diffuseRoughness, dot, float, hash, length, materialEmissive, max, mix, normalize, normalWorld, positionWorld, pow, smoothstep, vec3, vec4, } from 'three/tsl';
+import { MeshBasicNodeMaterial, PhysicalLightingModel, MeshStandardNodeMaterial as StandardNodeMaterial, } from 'three/webgpu';
+import { isHighlight } from '../editor-highlight';
+import { SCENE_LAYER } from '../layers';
+import { daylightRooms } from './rooms';
+import { daylightUniforms, isDaylightRenderer } from './runtime';
+/** sRGB 40 / 243 in linear: lo + c·(hi − lo). */
+const ALBEDO_LO = 0.0212;
+const ALBEDO_HI = 0.896;
+function hooked(material, builder) {
+    // Physical materials own their lighting model; glass and other transparent surfaces keep theirs.
+    return (!material.isMeshPhysicalNodeMaterial &&
+        !material.transparent &&
+        isDaylightRenderer(builder.renderer));
+}
+function matte(material) {
+    return (material.metalness ?? 0) < 0.2 && (material.roughness ?? 1) >= 0.55;
+}
+function emitter(material) {
+    return (!material.emissiveNode &&
+        !isHighlight(material) &&
+        !!material.emissive &&
+        material.emissive.getHex() !== 0 &&
+        material.emissiveIntensity > 0);
+}
+/** Window/door glass (its slot, live or baked), item glass by material name, or flagged glass. */
+function glass(material, object) {
+    if (!material.transparent || material.isMeshPhysicalNodeMaterial)
+        return false;
+    return (object?.userData?.slotId === 'glass' ||
+        material.userData.isGlass === true ||
+        /glass/i.test(material.name));
+}
+/** The enhanced viewer's glass: tint, near-mirror roughness, distance/Fresnel opacity, night glow. */
+function tunedGlassNodes() {
+    const u = daylightUniforms;
+    const V = normalize(cameraPosition.sub(positionWorld));
+    const N = normalWorld;
+    const fresnel = pow(float(1).sub(abs(dot(N, V))), 5);
+    // /next trick: glass gets more opaque + reflective with distance and grazing angle, so façades
+    // read as glazing from the street while interiors stay visible up close.
+    const far = smoothstep(6, 30, length(cameraPosition.sub(positionWorld)));
+    // Night: warm radiance from the lit room behind the pane (strongest from outside / far away).
+    const behind = daylightRooms.roomAtNode(positionWorld.sub(N.mul(0.35)));
+    const front = daylightRooms.roomAtNode(positionWorld.add(N.mul(0.35)));
+    const room = max(behind, front);
+    // Pane tint = the room's actual lamp colour (18% towards white), dark when its lamps are off.
+    const lampRad = daylightRooms.roomGlowNode(room);
+    const tint = mix(lampRad, vec3(lampRad.dot(vec3(0.33))), 0.18);
+    // Per-room variation, like a game city: not every window equally bright.
+    const variation = mix(0.55, 1.0, hash(float(room).add(7.13)));
+    const strength = u.windowGlow
+        .mul(u.glowComp)
+        .mul(float(1).add(u.windowEmit.mul(1.8)))
+        .mul(variation)
+        .mul(mix(1.0, 0.35, fresnel))
+        .mul(mix(0.25, 1.0, u.cameraOutside))
+        .mul(mix(0.4, 1, far));
+    return {
+        colorNode: u.glassTint,
+        roughnessNode: float(0.04),
+        metalnessNode: float(0),
+        opacityNode: clamp(u.glassOpacity.add(far.mul(0.18)).add(fresnel.mul(0.7)), 0, 0.72),
+        emissiveNode: tint.mul(strength).mul(0.9),
+    };
+}
+let installed = false;
+export function installDaylightMaterialHooks() {
+    if (installed)
+        return;
+    installed = true;
+    const proto = StandardNodeMaterial.prototype;
+    const setup = proto.setup;
+    proto.setup = function (builder) {
+        if (!isDaylightRenderer(builder.renderer) || !glass(this, builder.object))
+            return setup.call(this, builder);
+        // Build-time only: the tuned glass joins this compile without touching the material.
+        const own = this;
+        const nodes = tunedGlassNodes();
+        const saved = Object.fromEntries(Object.keys(nodes).map((key) => [key, own[key]]));
+        Object.assign(own, nodes);
+        try {
+            return setup.call(this, builder);
+        }
+        finally {
+            Object.assign(own, saved);
+        }
+    };
+    const setupDiffuseColor = proto.setupDiffuseColor;
+    proto.setupDiffuseColor = function (builder) {
+        setupDiffuseColor.call(this, builder);
+        if (!hooked(this, builder))
+            return;
+        const rgb = diffuseColor.rgb;
+        const clamped = rgb.mul(ALBEDO_HI - ALBEDO_LO).add(ALBEDO_LO);
+        diffuseColor.assign(vec4(mix(rgb, clamped, daylightUniforms.albedoClamp), diffuseColor.a));
+    };
+    const setupVariants = proto.setupVariants;
+    proto.setupVariants = function (builder) {
+        setupVariants.call(this, builder);
+        if (hooked(this, builder) && matte(this))
+            diffuseRoughness.assign(daylightUniforms.eon);
+    };
+    const setupLightingModel = proto.setupLightingModel;
+    proto.setupLightingModel = function (builder) {
+        if (!hooked(this, builder) || !matte(this))
+            return setupLightingModel.call(this, builder);
+        // The eighth flag enables EON rough diffuse (fed by `diffuseRoughness` above).
+        return new PhysicalLightingModel(false, false, false, false, false, false, false, true);
+    };
+    const setupLighting = proto.setupLighting;
+    proto.setupLighting = function (builder) {
+        if (hooked(this, builder) && !this.emissiveNode && isHighlight(this)) {
+            // Editor highlights: the tint keeps its on-screen strength whatever the exposure.
+            this.emissiveNode = materialEmissive.mul(daylightUniforms.emitterExpInv);
+            try {
+                return setupLighting.call(this, builder);
+            }
+            finally {
+                this.emissiveNode = null;
+            }
+        }
+        if (!hooked(this, builder) || !emitter(this))
+            return setupLighting.call(this, builder);
+        // Build-time only: the emission joins this compile without touching the material.
+        // Glowing surfaces (screens, signs; lamps get their own materials): brighter at night, kept
+        // out of the night exposure lift.
+        const u = daylightUniforms;
+        this.emissiveNode = materialEmissive.mul(float(1).add(u.lampLevel.mul(u.emissiveBoost).mul(u.glowComp)));
+        try {
+            return setupLighting.call(this, builder);
+        }
+        finally {
+            this.emissiveNode = null;
+        }
+    };
+    // Unlit scene surfaces: undo the metered exposure (zones and editor overlays are compensated in
+    // the post-processing, on their own layers; the sky capture is radiance and keeps it).
+    const basic = MeshBasicNodeMaterial.prototype;
+    const setupBasicLighting = basic.setupLighting;
+    basic.setupLighting = function (builder) {
+        const light = setupBasicLighting.call(this, builder);
+        const object = builder.object;
+        if (!isDaylightRenderer(builder.renderer) ||
+            this.userData.daylightSky === true ||
+            !object?.layers?.isEnabled(SCENE_LAYER))
+            return light;
+        return light.mul(daylightUniforms.emitterExpInv);
+    };
+}

package/dist/lib/daylight/room-context.d.ts

@@ -0,0 +1,12 @@
+type N = any;
+/**
+ * The daylight look's scene-pass lighting hooks: room light enters the material lighting as
+ * indirect irradiance (`getGI`, × albedo, × contact AO), the room enclosure dims the sky IBL
+ * (`getAO`), and outside surfaces receive the window spill and exterior lamps at night.
+ *
+ * Materials flagged `userData.noRooms` (the grounds) skip the room system: the dilated room
+ * map reaches ~20 cm past the walls and would light a strip of lawn.
+ */
+export declare function daylightRoomContext(): N;
+export {};
+//# sourceMappingURL=room-context.d.ts.map

package/dist/lib/daylight/room-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-context.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/room-context.ts"],"names":[],"mappings":"AAaA,KAAK,CAAC,GAAG,GAAG,CAAA;AAKZ;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,IAAI,CAAC,CAoCvC"}

package/dist/lib/daylight/room-context.js

@@ -0,0 +1,53 @@
+import { context, diffuseColor, Fn, If, max, normalWorld, positionWorld, uniform, vec3, } from 'three/tsl';
+import { daylightRooms } from './rooms';
+/** Window spill only: receivers darker than this albedo are lit as if they had it (decal-style). */
+const spillAlbedoFloor = uniform(0.35);
+/**
+ * The daylight look's scene-pass lighting hooks: room light enters the material lighting as
+ * indirect irradiance (`getGI`, × albedo, × contact AO), the room enclosure dims the sky IBL
+ * (`getAO`), and outside surfaces receive the window spill and exterior lamps at night.
+ *
+ * Materials flagged `userData.noRooms` (the grounds) skip the room system: the dilated room
+ * map reaches ~20 cm past the walls and would light a strip of lawn.
+ */
+export function daylightRoomContext() {
+    const rooms = daylightRooms;
+    const roomNode = rooms.lightingNode();
+    const enclosure = roomNode.w;
+    const outsideMask = rooms.exteriorMaskNode();
+    // GI is later × albedo, so near-black paving would swallow the pools: lift dark receivers for
+    // the spill term only (like a light decal).
+    const lum = diffuseColor.rgb.dot(vec3(0.2126, 0.7152, 0.0722)).max(1e-3);
+    const albedoLift = lum.max(spillAlbedoFloor).div(lum);
+    const spill = rooms.exteriorSpillNode(positionWorld, normalWorld).mul(albedoLift);
+    const exteriorLamps = rooms.exteriorLampsNode(positionWorld, normalWorld);
+    // Inside a room the outside terms are masked to nothing anyway: skip their loops there.
+    const outsideLight = Fn(() => {
+        const light = vec3(0).toVar();
+        If(outsideMask.greaterThan(0), () => {
+            light.assign(spill.add(exteriorLamps).mul(outsideMask));
+        });
+        return light;
+    })();
+    return context({
+        getAO: (input, { material }) => {
+            if (material.transparent === true)
+                return input;
+            if (material.userData.noRooms)
+                return input;
+            return input !== null ? input.mul(enclosure) : enclosure;
+        },
+        getGI: (input, { material }) => {
+            if (material.transparent === true)
+                return input;
+            // The lighting model multiplies GI by the AO term again: undo it so room light keeps only
+            // the contact AO, and outside terms aren't dimmed by an enclosure they don't sit in.
+            let gi;
+            if (material.userData.noRooms)
+                gi = spill.add(exteriorLamps);
+            else
+                gi = outsideLight.add(roomNode.xyz).div(max(enclosure, 1e-3));
+            return input !== null ? input.add(gi) : gi;
+        },
+    });
+}

package/dist/lib/daylight/room-scene.d.ts

@@ -0,0 +1,54 @@
+import { type Object3D, Vector3 } from 'three';
+import type { RoomLamp, RoomSceneInput } from './rooms';
+/**
+ * Builds the room system's input from a scene: the live parametric graph (scene registry +
+ * node data) or a baked artifact (identity `userData` stamped by the GLB export).
+ */
+/** A lamp as the item-light pools see it (live catalog/procedural items and baked items alike). */
+export type LampFeedLight = {
+    key: string;
+    color: string;
+    distance: number;
+    /** Fully-on intensity. */
+    peak?: number;
+    getWorldPosition: (out: Vector3) => boolean;
+    /** The lamp's item: its node id (live) or object (baked). */
+    nodeId?: string;
+    object?: Object3D;
+    /** A spotlight's cone (angle in degrees, full cone; softness = penumbra) and its aim. */
+    spot?: {
+        direction?: readonly [number, number, number];
+        angle?: number;
+        softness?: number;
+    };
+    getWorldDirection?: (out: Vector3) => void;
+};
+type LampFeed = {
+    lights: () => Iterable<LampFeedLight>;
+    intensity: (light: LampFeedLight) => number;
+};
+/** Item-light pools hand their lamps to the room system while the daylight look is active. */
+export declare const lampFeeds: Set<LampFeed>;
+/** Lamps from every registered feed, in the room system's units. */
+export declare function feedLamps(): RoomLamp[];
+/** Current on/off of a fed lamp (by key). */
+export declare function feedLampOn(key: string): boolean | undefined;
+/** The live parametric scene (registry + node data), or null while it has no zones. */
+export declare function liveRoomScene(virtualLampsOn: boolean): RoomSceneInput | null;
+/** Live level objects in the room system's level order (for explode offsets). */
+export declare function liveLevelObjects(): Object3D[];
+/** How open a live door is (0 closed … 1 fully open), the transient state first. */
+export declare function liveDoorOpenness(id: string): number;
+/** A baked artifact's identity tree (levels, zones, covers, walls, openings), or null. */
+export declare function bakedRoomScene(root: Object3D, virtualLampsOn: boolean): RoomSceneInput | null;
+/**
+ * Lamp shades and bulbs follow their own lamp (the enhanced viewer's isolated emitters): each
+ * lamp's emissive meshes get private materials whose emission follows that lamp's switch. A light
+ * can sit on a child item while the glowing mesh belongs to its parent item: search the item, then
+ * its nearest item ancestor. Re-installed if the item swaps its materials.
+ */
+export declare function syncLampEmitters(): void;
+/** The lamps' own materials back (the daylight look left). */
+export declare function restoreLampEmitters(): void;
+export {};
+//# sourceMappingURL=room-scene.d.ts.map

package/dist/lib/daylight/room-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-scene.d.ts","sourceRoot":"","sources":["../../../src/lib/daylight/room-scene.ts"],"names":[],"mappings":"AAQA,OAAO,EAAoD,KAAK,QAAQ,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAKhG,OAAO,KAAK,EAAE,QAAQ,EAAmB,cAAc,EAAY,MAAM,SAAS,CAAA;AAGlF;;;GAGG;AAEH,mGAAmG;AACnG,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,0BAA0B;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,gBAAgB,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;IAC3C,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,QAAQ,CAAA;IACjB,yFAAyF;IACzF,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC3F,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CAC3C,CAAA;AAED,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,QAAQ,CAAC,aAAa,CAAC,CAAA;IACrC,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,MAAM,CAAA;CAC5C,CAAA;AAED,8FAA8F;AAC9F,eAAO,MAAM,SAAS,eAAsB,CAAA;AAU5C,oEAAoE;AACpE,wBAAgB,SAAS,IAAI,QAAQ,EAAE,CAuBtC;AAeD,6CAA6C;AAC7C,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAK3D;AAcD,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,cAAc,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CAgE5E;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,IAAI,QAAQ,EAAE,CAQ7C;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAanD;AAQD,0FAA0F;AAC1F,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CA+E7F;AAiED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CA2CvC;AAED,8DAA8D;AAC9D,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C"}