@pascal-app/viewer 1.0.0-beta.4 → 1.0.0

package/dist/index.js

@@ -17,9 +17,13 @@ export { buildGlbReferenceNodes, buildGlbReplaceNodes, } from './components/view
 export { GlbScene, } from './components/viewer/glb-scene';
 export { CROUCH_CAPSULE, CROUCH_EYE_OFFSET, CROUCH_FLOAT_HEIGHT, CROUCH_RUN_SPEED, CROUCH_WALK_SPEED, EYE_LERP_SPEED, GlbWalkthroughController, STAND_CAPSULE, STAND_CLEARANCE, STAND_FLOAT_HEIGHT, WALKTHROUGH_FOV, } from './components/viewer/glb-walkthrough-controller';
 export { DEFAULT_HOVER_STYLES, SSGI_PARAMS, } from './components/viewer/post-processing';
+export { SceneAtmosphere, useSceneAtmosphere, } from './components/viewer/scene-atmosphere';
 export { SceneEnvironment } from './components/viewer/scene-environment';
+export { SceneGroundReplacement, useSceneGroundReplacement, } from './components/viewer/scene-ground-replacement';
+export { isViewerPresentationTextureBorrowed, markViewerPresentationTextureBorrowed, registerViewerPresentation, ViewerPresentations, viewerPresentationRegistry, } from './components/viewer/viewer-presentations';
 export { useAssetUrl } from './hooks/use-asset-url';
 export { useGLTFKTX2 } from './hooks/use-gltf-ktx2';
+export { useLibraryMaterialsVersion } from './hooks/use-library-materials-version';
 export { useNodeEvents } from './hooks/use-node-events';
 export { ASSETS_CDN_URL, resolveAssetUrl, resolveCdnUrl } from './lib/asset-url';
 export { backdropGradient, deepSkyColor, horizonHazeColor } from './lib/backdrop';
@@ -28,15 +32,23 @@ 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, INTERSECTION, prepareBrushForCSG, SUBTRACTION, } from './lib/csg-utils';
+export { disposeObject3DResources } from './lib/dispose-object3d';
+export { PERF_OVERLAY_ENABLED } from './lib/gpu-perf';
 export { computeHeroFraming, DEFAULT_FRAMING_EXCLUDED_TYPES, heroCameraPose, temporarilyHideNodeTypes, unionRegisteredNodeBounds, } from './lib/hero-pose';
 export { applyIsolation, clearIsolation, collectIsolationSubtree, isIsolationActive, } from './lib/isolation';
 export { configureKtx2Support, ensureKtx2Support } from './lib/ktx2-loader';
-export { GRID_LAYER, OVERLAY_LAYER, SCENE_LAYER, ZONE_LAYER } from './lib/layers';
-export { applyMaterialPresetToMaterials, BLUEPRINT_PALETTE, baseMaterial, CLAY_PALETTE, clearMaterialCache, createDefaultMaterial, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, DEFAULT_CEILING_MATERIAL, DEFAULT_DOOR_MATERIAL, DEFAULT_ROOF_MATERIAL, DEFAULT_SHELF_MATERIAL, DEFAULT_SLAB_MATERIAL, DEFAULT_STAIR_MATERIAL, DEFAULT_WALL_MATERIAL, DEFAULT_WINDOW_MATERIAL, disposeMaterial, glassMaterial, MONO_PALETTE, PRESET_PALETTES, resolveMaterialRef, resolveSlotDefaultMaterial, resolveSurfaceColor, WHITE_PALETTE, } from './lib/materials';
+export { LayerPassIndex } from './lib/layer-pass';
+export { BATCHED_LAYER, GRID_LAYER, OVERLAY_LAYER, SCENE_LAYER, SHADOW_ONLY_LAYER, setSurfaceRaycastLayers, ZONE_LAYER, } from './lib/layers';
+export { applyMaterialPresetToMaterials, BLUEPRINT_PALETTE, baseMaterial, CLAY_PALETTE, clearMaterialCache, createDefaultMaterial, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, DEFAULT_CEILING_MATERIAL, DEFAULT_DOOR_MATERIAL, DEFAULT_ROOF_MATERIAL, DEFAULT_SHELF_MATERIAL, DEFAULT_SLAB_MATERIAL, DEFAULT_STAIR_MATERIAL, DEFAULT_WALL_MATERIAL, DEFAULT_WINDOW_MATERIAL, disposeMaterial, glassMaterial, MONO_PALETTE, PRESET_PALETTES, registerMaterialCacheCleanup, resolveMaterialRef, resolveSlotDefaultMaterial, resolveSurfaceColor, WHITE_PALETTE, } from './lib/materials';
 export { mergedOutline } from './lib/merged-outline-node';
-export { unionPolygons } from './lib/polygon-union';
+export * from './lib/perf-actions';
+export { publishPerfBatchStats } from './lib/perf-panel-store';
+export * from './lib/perf-tracks';
+export { markPureRaycast } from './lib/pointer-events';
+export { detectRendererCapability, initializeGpuRenderer, } from './lib/renderer-capability';
 export { getSceneTheme, SCENE_THEME_IDS, SCENE_THEMES, } from './lib/scene-themes';
-export { createSnapshotPipeline, THUMBNAIL_HEIGHT, THUMBNAIL_WIDTH, } from './lib/snapshot-pipeline';
+export { hideFromScene, showInScene, temporarilyShowShadowOnly, } from './lib/scene-visibility';
+export { 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';
@@ -64,7 +76,7 @@ export { InteractiveSystem } from './systems/interactive/interactive-system';
 export { ItemSystem } from './systems/item/item-system';
 export { ItemLightSystem } from './systems/item-light/item-light-system';
 export { LevelSystem } from './systems/level/level-system';
-export { snapLevelsToTruePositions } from './systems/level/level-utils';
+export { EXPLODED_GAP, getLevelPresentationY, snapLevelsToTruePositions, } from './systems/level/level-utils';
 export { getRoofMaterialArray } 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)
@@ -81,13 +93,13 @@ export { StairSystem } from './systems/stair/stair-system';
 // roof-wall opening cuts in `@pascal-app/nodes` — keeps shaped holes
 // (arch / rounded / frameless opening) identical across both hosts.
 export { buildOpeningCutoutGeometry, getOpeningCutoutBottomPadding, hasFlatOpeningCutoutBottom, } from './systems/wall/opening-cutout-geometry';
-export { WallCutout } from './systems/wall/wall-cutout';
+export { getWallHideState, WallCutout } from './systems/wall/wall-cutout';
 export { getVisibleWallMaterials } from './systems/wall/wall-materials';
 // Wall internals re-exported so `@pascal-app/nodes`' registry-driven wall
 // definition can compose them into `def.system` without duplicating the
 // 800+ lines of CSG / mitering logic during Phase 3. These exports are
 // removed in Phase 6 when the legacy mount points are deleted.
-export { WallSystem } from './systems/wall/wall-system';
+export { drainRebuiltWalls, getPendingWallRebuildCount, isWallInitialBuildActive, WallSystem, } from './systems/wall/wall-system';
 export { poseWindowMovingParts, WindowAnimationSystem, } from './systems/window/window-animation-system';
 export { buildWindowPreviewMesh, WindowSystem } from './systems/window/window-system';
 export { ZoneSystem } from './systems/zone/zone-system';

package/dist/lib/csg-utils.d.ts

@@ -6,5 +6,6 @@ export declare function csgMaterials(brush: Brush): THREE.Material[];
 export declare const csgEvaluator: Evaluator;
 export declare function computeGeometryBoundsTree(geometry: THREE.BufferGeometry): void;
 export declare function prepareBrushForCSG(brush: Brush): void;
+export declare function subtractCsgBrush(left: Brush, right: Brush, evaluator: Evaluator): Brush;
 export { ADDITION, Brush, INTERSECTION, SUBTRACTION } from 'three-bvh-csg';
 //# sourceMappingURL=csg-utils.d.ts.map

package/dist/lib/csg-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"csg-utils.d.ts","sourceRoot":"","sources":["../../src/lib/csg-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAE,KAAK,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AA4CrD,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,KAAK,CAAC,cAAc,GAC7B,KAAK,CAAC,cAAc,CAoCtB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,cAAc,CAE9D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,QAAQ,EAAE,CAG3D;AAED,eAAO,MAAM,YAAY,WAAkB,CAAA;AAK3C,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,QAMvE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,QAI9C;AAID,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"csg-utils.d.ts","sourceRoot":"","sources":["../../src/lib/csg-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAE,KAAK,KAAK,EAAE,SAAS,EAAe,MAAM,eAAe,CAAA;AA4ClE,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,KAAK,CAAC,cAAc,GAC7B,KAAK,CAAC,cAAc,CAoCtB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,cAAc,CAE9D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,QAAQ,EAAE,CAG3D;AAED,eAAO,MAAM,YAAY,WAAkB,CAAA;AAK3C,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,QAMvE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,QAI9C;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,GAAG,KAAK,CAIvF;AAID,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/lib/csg-utils.js

@@ -1,5 +1,5 @@
 import * as THREE from 'three';
-import { Evaluator } from 'three-bvh-csg';
+import { Evaluator, SUBTRACTION } from 'three-bvh-csg';
 import { computeBoundsTree } from 'three-mesh-bvh';
 /**
  * Shared CSG primitives used by kinds whose geometry subtracts pieces
@@ -88,6 +88,11 @@ export function prepareBrushForCSG(brush) {
     computeGeometryBoundsTree(brush.geometry);
     brush.updateMatrixWorld();
 }
+export function subtractCsgBrush(left, right, evaluator) {
+    const result = evaluator.evaluate(left, right, SUBTRACTION);
+    prepareBrushForCSG(result);
+    return result;
+}
 // Re-export Brush + SUBTRACTION + ADDITION + INTERSECTION so kinds don't need a
 // direct `three-bvh-csg` dependency.
 export { ADDITION, Brush, INTERSECTION, SUBTRACTION } from 'three-bvh-csg';

package/dist/lib/dispose-object3d.d.ts

@@ -0,0 +1,4 @@
+import type { Object3D } from 'three';
+/** Dispose geometry and non-cached materials owned by an Object3D subtree. */
+export declare function disposeObject3DResources(root: Object3D): void;
+//# sourceMappingURL=dispose-object3d.d.ts.map

package/dist/lib/dispose-object3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispose-object3d.d.ts","sourceRoot":"","sources":["../../src/lib/dispose-object3d.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,QAAQ,EAAE,MAAM,OAAO,CAAA;AAM/D,8EAA8E;AAC9E,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAsB7D"}

package/dist/lib/dispose-object3d.js

@@ -0,0 +1,27 @@
+function isCachedMaterial(material) {
+    return Boolean(material.userData?.__pascalCachedMaterial);
+}
+/** Dispose geometry and non-cached materials owned by an Object3D subtree. */
+export function disposeObject3DResources(root) {
+    const geometries = new Set();
+    const materials = new Set();
+    root.traverse((object) => {
+        const renderable = object;
+        if (renderable.geometry)
+            geometries.add(renderable.geometry);
+        const objectMaterials = renderable.material;
+        if (Array.isArray(objectMaterials)) {
+            for (const material of objectMaterials)
+                materials.add(material);
+        }
+        else if (objectMaterials) {
+            materials.add(objectMaterials);
+        }
+    });
+    for (const geometry of geometries)
+        geometry.dispose();
+    for (const material of materials) {
+        if (!isCachedMaterial(material))
+            material.dispose();
+    }
+}

package/dist/lib/geometry-groups.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+/**
+ * Rewrites a geometry's material groups so every material is drawn exactly once.
+ *
+ * A group is a contiguous slice of the index buffer, so a mesh whose triangles
+ * alternate between materials pays a draw call per *run*, not per material.
+ * Extruded walls hit this hard: `ExtrudeGeometry` emits the cap and side faces
+ * interleaved, so run-length grouping produces four groups for two materials —
+ * multiplied by a thousand walls, that is thousands of avoidable draw calls.
+ * Bucketing the triangles by material first makes each material one run.
+ *
+ * The geometry gains an index buffer if it had none. Triangle winding, vertex
+ * data and material assignment are untouched, so the rendered image is
+ * unchanged; only the order in which the GPU is asked to draw it differs.
+ */
+export declare function setGroupsSortedByMaterial(geometry: THREE.BufferGeometry, triangleMaterials: ArrayLike<number>): void;
+//# sourceMappingURL=geometry-groups.d.ts.map

package/dist/lib/geometry-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-groups.d.ts","sourceRoot":"","sources":["../../src/lib/geometry-groups.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,iBAAiB,EAAE,SAAS,CAAC,MAAM,CAAC,GACnC,IAAI,CA2CN"}

package/dist/lib/geometry-groups.js

@@ -0,0 +1,53 @@
+import * as THREE from 'three';
+/**
+ * Rewrites a geometry's material groups so every material is drawn exactly once.
+ *
+ * A group is a contiguous slice of the index buffer, so a mesh whose triangles
+ * alternate between materials pays a draw call per *run*, not per material.
+ * Extruded walls hit this hard: `ExtrudeGeometry` emits the cap and side faces
+ * interleaved, so run-length grouping produces four groups for two materials —
+ * multiplied by a thousand walls, that is thousands of avoidable draw calls.
+ * Bucketing the triangles by material first makes each material one run.
+ *
+ * The geometry gains an index buffer if it had none. Triangle winding, vertex
+ * data and material assignment are untouched, so the rendered image is
+ * unchanged; only the order in which the GPU is asked to draw it differs.
+ */
+export function setGroupsSortedByMaterial(geometry, triangleMaterials) {
+    geometry.clearGroups();
+    const position = geometry.getAttribute('position');
+    if (!position)
+        return;
+    const sourceIndex = geometry.getIndex();
+    const triangleCount = Math.min(triangleMaterials.length, sourceIndex ? Math.floor(sourceIndex.count / 3) : Math.floor(position.count / 3));
+    if (triangleCount === 0)
+        return;
+    const buckets = new Map();
+    for (let triangle = 0; triangle < triangleCount; triangle += 1) {
+        const material = triangleMaterials[triangle] ?? 0;
+        const bucket = buckets.get(material);
+        if (bucket)
+            bucket.push(triangle);
+        else
+            buckets.set(material, [triangle]);
+    }
+    const singleMaterial = buckets.size === 1 ? [...buckets.keys()][0] : undefined;
+    if (singleMaterial !== undefined) {
+        geometry.addGroup(0, triangleCount * 3, singleMaterial);
+        return;
+    }
+    const reordered = new Uint32Array(triangleCount * 3);
+    let cursor = 0;
+    for (const [material, triangles] of [...buckets].sort((left, right) => left[0] - right[0])) {
+        const groupStart = cursor;
+        for (const triangle of triangles) {
+            const base = triangle * 3;
+            reordered[cursor] = sourceIndex ? sourceIndex.getX(base) : base;
+            reordered[cursor + 1] = sourceIndex ? sourceIndex.getX(base + 1) : base + 1;
+            reordered[cursor + 2] = sourceIndex ? sourceIndex.getX(base + 2) : base + 2;
+            cursor += 3;
+        }
+        geometry.addGroup(groupStart, cursor - groupStart, material);
+    }
+    geometry.setIndex(new THREE.BufferAttribute(reordered, 1));
+}

package/dist/lib/gpu-perf.d.ts

@@ -1,4 +1,2 @@
 export declare const PERF_OVERLAY_ENABLED: boolean;
-export declare function pushGpuSample(ms: number): void;
-export declare function drainGpuSamples(): number[];
 //# sourceMappingURL=gpu-perf.d.ts.map

package/dist/lib/gpu-perf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpu-perf.d.ts","sourceRoot":"","sources":["../../src/lib/gpu-perf.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,oBAAoB,SACyD,CAAA;AAK1F,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAG9C;AAED,wBAAgB,eAAe,IAAI,MAAM,EAAE,CAK1C"}
+{"version":3,"file":"gpu-perf.d.ts","sourceRoot":"","sources":["../../src/lib/gpu-perf.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,oBAAoB,SACyD,CAAA"}

package/dist/lib/gpu-perf.js

@@ -1,23 +1,9 @@
-// GPU work-time measurement, gated by `?perf` in the URL.
+// `?perf` gate. Kept in its own module because both the overlay and
+// `lib/perf-tracks.ts` (the instrumentation sink every system writes to) read
+// it, and perf-tracks must not import a React component tree.
 //
-// We can't use WebGPU timestamp queries here because the editor renders via
-// a custom `RenderPipeline.render()` path that bypasses three.js's built-in
-// timestamp infrastructure. Instead we use `device.queue.onSubmittedWorkDone()`,
-// which resolves when the GPU finishes all submitted work — measuring the
-// CPU→GPU-done delta gives a clean approximation of per-frame GPU duration
-// regardless of which render path produced it.
+// Timing itself lives in perf-tracks: `gpu-render` carries three's WebGPU
+// timestamp-query total for the frame's render passes, `gpu-queue` the
+// submit→onSubmittedWorkDone fence, `render-encode` the synchronous CPU cost of
+// building and submitting the frame. See components/viewer/post-processing.tsx.
 export const PERF_OVERLAY_ENABLED = typeof window !== 'undefined' && new URLSearchParams(window.location.search).has('perf');
-const MAX_SAMPLES = 256;
-const samples = [];
-export function pushGpuSample(ms) {
-    samples.push(ms);
-    if (samples.length > MAX_SAMPLES)
-        samples.shift();
-}
-export function drainGpuSamples() {
-    if (samples.length === 0)
-        return [];
-    const out = samples.slice();
-    samples.length = 0;
-    return out;
-}

package/dist/lib/isolation.d.ts

@@ -15,21 +15,21 @@ export declare function collectIsolationSubtree(ids: ReadonlyArray<string>): Set
 /**
  * Imperative visibility filter on the live `sceneRegistry`. Hides every
  * registered group (and its synthesized child meshes) outside the
- * isolated subtree by disabling the {@link SCENE_LAYER} bit on the
- * relevant `Object3D.layers` masks.
+ * isolated subtree by taking it off the scene layer.
  *
  * Why layers instead of `obj.visible = false`? Three.js's visibility
  * flag *cascades* — hiding a parent hides every descendant — so we
  * can't hide a host wall while keeping a door rendered inside it.
  * Layer masks are per-object and don't cascade: `WebGLRenderer
  * .projectObject` skips objects whose layer mask doesn't intersect the
- * camera's, but always recurses into their children. So we can disable
- * `SCENE_LAYER` on the wall and the door (hosted under it in the
- * scene graph) still renders, with its local position relative to the
- * wall preserved automatically by the matrix walk.
+ * camera's, but always recurses into their children. So we can hide
+ * the wall and the door (hosted under it in the scene graph) still
+ * renders, with its local position relative to the wall preserved
+ * automatically by the matrix walk.
  *
- * The original `layers.mask` is stashed under a private Symbol so
- * {@link clearIsolation} can restore the exact prior state.
+ * The mask itself belongs to `lib/scene-visibility.ts`, which reconciles
+ * isolation with solo's shadow-caster pass, so {@link clearIsolation}
+ * gives an object back only what isolation took.
  *
  * Pass `null` to clear isolation (equivalent to calling
  * {@link clearIsolation}).

package/dist/lib/isolation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isolation.d.ts","sourceRoot":"","sources":["../../src/lib/isolation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAgBrC,8EAA8E;AAC9E,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,CAUjF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,GAAG,IAAI,CAiBzE;AAcD,wBAAgB,cAAc,IAAI,IAAI,CAcrC"}
+{"version":3,"file":"isolation.d.ts","sourceRoot":"","sources":["../../src/lib/isolation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AASrC,8EAA8E;AAC9E,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,CAUjF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,GAAG,IAAI,CAiBzE;AAUD,wBAAgB,cAAc,IAAI,IAAI,CAUrC"}

package/dist/lib/isolation.js

@@ -1,12 +1,8 @@
 'use client';
 import { sceneRegistry } from '@pascal-app/core';
-import { SCENE_LAYER } from './layers';
-// Marker on each Object3D we modify during isolation so we can restore
-// the original `layers.mask` bitfield. Stored under a `Symbol` so it
-// can't collide with any kind's own userData fields.
-const ORIGINAL_LAYERS = Symbol('isolation:original-layers');
-// Whether a subtree is currently isolated (some objects have SCENE_LAYER
-// disabled). Read by consumers that must not act on the partial view — e.g.
+import { hideFromScene, showInScene } from './scene-visibility';
+// Whether a subtree is currently isolated (some objects are held off the
+// scene layer). Read by consumers that must not act on the partial view — e.g.
 // the project-thumbnail autosave skips capturing while isolated so it never
 // snapshots a single focused item as the whole project's thumbnail.
 let isolationActive = false;
@@ -38,21 +34,21 @@ export function collectIsolationSubtree(ids) {
 /**
  * Imperative visibility filter on the live `sceneRegistry`. Hides every
  * registered group (and its synthesized child meshes) outside the
- * isolated subtree by disabling the {@link SCENE_LAYER} bit on the
- * relevant `Object3D.layers` masks.
+ * isolated subtree by taking it off the scene layer.
  *
  * Why layers instead of `obj.visible = false`? Three.js's visibility
  * flag *cascades* — hiding a parent hides every descendant — so we
  * can't hide a host wall while keeping a door rendered inside it.
  * Layer masks are per-object and don't cascade: `WebGLRenderer
  * .projectObject` skips objects whose layer mask doesn't intersect the
- * camera's, but always recurses into their children. So we can disable
- * `SCENE_LAYER` on the wall and the door (hosted under it in the
- * scene graph) still renders, with its local position relative to the
- * wall preserved automatically by the matrix walk.
+ * camera's, but always recurses into their children. So we can hide
+ * the wall and the door (hosted under it in the scene graph) still
+ * renders, with its local position relative to the wall preserved
+ * automatically by the matrix walk.
  *
- * The original `layers.mask` is stashed under a private Symbol so
- * {@link clearIsolation} can restore the exact prior state.
+ * The mask itself belongs to `lib/scene-visibility.ts`, which reconciles
+ * isolation with solo's shadow-caster pass, so {@link clearIsolation}
+ * gives an object back only what isolation took.
  *
  * Pass `null` to clear isolation (equivalent to calling
  * {@link clearIsolation}).
@@ -64,9 +60,9 @@ export function applyIsolation(ids) {
     }
     const keep = collectIsolationSubtree(ids);
     // Iterate registered roots. For each one outside the keep set,
-    // disable `SCENE_LAYER` on it and on every descendant — *except*
-    // descendants that are themselves in `keep` (a kept node nested under
-    // a non-kept host: the isolated door under the hidden wall).
+    // hide it and every descendant — *except* descendants that are
+    // themselves in `keep` (a kept node nested under a non-kept host:
+    // the isolated door under the hidden wall).
     for (const [, obj] of sceneRegistry.nodes) {
         if (keep.has(obj))
             continue;
@@ -77,26 +73,18 @@ export function applyIsolation(ids) {
 function hideRecursive(obj, keep) {
     if (keep.has(obj))
         return;
-    const carrier = obj;
-    if (carrier[ORIGINAL_LAYERS] === undefined) {
-        carrier[ORIGINAL_LAYERS] = obj.layers.mask;
-    }
-    obj.layers.disable(SCENE_LAYER);
+    hideFromScene(obj, 'isolated');
     for (const child of obj.children) {
         hideRecursive(child, keep);
     }
 }
 export function clearIsolation() {
     // We don't know which objects were touched without re-walking, so
-    // walk every registered root + its descendants and restore any
-    // stashed original-mask. `traverse` is cheap and idempotent here.
+    // walk every registered root + its descendants and drop the isolation
+    // reason wherever it was set. `traverse` is cheap and idempotent here.
     for (const [, obj] of sceneRegistry.nodes) {
         obj.traverse((child) => {
-            const carrier = child;
-            if (carrier[ORIGINAL_LAYERS] !== undefined) {
-                child.layers.mask = carrier[ORIGINAL_LAYERS];
-                delete carrier[ORIGINAL_LAYERS];
-            }
+            showInScene(child, 'isolated');
         });
     }
     isolationActive = false;

package/dist/lib/layer-pass.d.ts

@@ -0,0 +1,28 @@
+import { type Camera, Object3D, type Scene } from 'three';
+import { type NodeFrame, PassNode } from 'three/webgpu';
+export declare class LayerPassIndex {
+    readonly source: Scene;
+    private readonly members;
+    private readonly cleanups;
+    constructor(source: Scene, layers: number[]);
+    register(subtree: Object3D): void;
+    private attach;
+    private detach;
+    prepare(layer: number, roots: Object3D[]): {
+        drawable: boolean;
+        shadowLight: boolean;
+    };
+    dispose(): void;
+}
+export declare class LayerPassNode extends PassNode {
+    private readonly index;
+    private readonly layer;
+    private readonly mainPass;
+    private readonly roots;
+    private readonly size;
+    private needsClear;
+    constructor(index: LayerPassIndex, camera: Camera, layer: number, mainPass: PassNode);
+    dispose(): void;
+    updateBefore(frame: NodeFrame): undefined;
+}
+//# sourceMappingURL=layer-pass.d.ts.map

package/dist/lib/layer-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-pass.d.ts","sourceRoot":"","sources":["../../src/lib/layer-pass.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,EAAiB,QAAQ,EAAE,KAAK,KAAK,EAAW,MAAM,OAAO,CAAA;AACjF,OAAO,EAAE,KAAK,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAoBvD,qBAAa,cAAc;IAKvB,QAAQ,CAAC,MAAM,EAAE,KAAK;IAJxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAC3D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;gBAGhD,MAAM,EAAE,KAAK,EACtB,MAAM,EAAE,MAAM,EAAE;IAWlB,QAAQ,CAAC,OAAO,EAAE,QAAQ;IAU1B,OAAO,CAAC,MAAM,CA2Cb;IAED,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE;;;;IAoCxC,OAAO;CAIR;AAiBD,qBAAa,aAAc,SAAQ,QAAQ;IAMvC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAEtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAR3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,OAAO,CAAC,UAAU,CAAO;gBAGN,KAAK,EAAE,cAAc,EACtC,MAAM,EAAE,MAAM,EACG,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ;IAc5B,OAAO;IAKP,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS;CAgEnD"}