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

package/dist/lib/csg-utils.js

@@ -1,3 +1,4 @@
+import * as THREE from 'three';
 import { Evaluator } from 'three-bvh-csg';
 import { computeBoundsTree } from 'three-mesh-bvh';
 /**
@@ -7,8 +8,66 @@ import { computeBoundsTree } from 'three-mesh-bvh';
  * three-bvh-csg + three-mesh-bvh are viewer-only deps; kinds living
  * in `@pascal-app/nodes` import these through the public surface.
  */
+function zeroAttribute(count, itemSize) {
+    return new THREE.Float32BufferAttribute(new Float32Array(count * itemSize), itemSize);
+}
+function upNormalAttribute(count) {
+    const values = new Float32Array(count * 3);
+    for (let index = 0; index < count; index += 1) {
+        values[index * 3 + 1] = 1;
+    }
+    return new THREE.Float32BufferAttribute(values, 3);
+}
+function ensureAttributeCount(geometry, name, itemSize, count) {
+    const attribute = geometry.getAttribute(name);
+    if (attribute?.count === count && attribute.itemSize === itemSize)
+        return;
+    geometry.setAttribute(name, zeroAttribute(count, itemSize));
+}
+function copyVec2Attribute(attribute) {
+    const values = new Float32Array(attribute.count * 2);
+    for (let index = 0; index < attribute.count; index += 1) {
+        values[index * 2] = attribute.getX(index);
+        values[index * 2 + 1] = attribute.getY(index);
+    }
+    return new THREE.Float32BufferAttribute(values, 2);
+}
+export function ensureRenderableGeometryAttributes(geometry) {
+    const position = geometry.getAttribute('position');
+    if (!position || position.count === 0 || position.itemSize !== 3) {
+        geometry.setIndex(null);
+        geometry.clearGroups();
+        geometry.setAttribute('position', zeroAttribute(3, 3));
+        geometry.setAttribute('normal', upNormalAttribute(3));
+        geometry.setAttribute('uv', zeroAttribute(3, 2));
+        geometry.setAttribute('uv2', zeroAttribute(3, 2));
+        return geometry;
+    }
+    const count = position.count;
+    const normal = geometry.getAttribute('normal');
+    if (normal?.count !== count || normal.itemSize !== 3) {
+        geometry.deleteAttribute('normal');
+        try {
+            geometry.computeVertexNormals();
+        }
+        catch {
+            geometry.deleteAttribute('normal');
+        }
+    }
+    const computedNormal = geometry.getAttribute('normal');
+    if (computedNormal?.count !== count || computedNormal.itemSize !== 3) {
+        geometry.setAttribute('normal', upNormalAttribute(count));
+    }
+    ensureAttributeCount(geometry, 'uv', 2, count);
+    const uv = geometry.getAttribute('uv');
+    const uv2 = geometry.getAttribute('uv2');
+    if (uv2?.count !== count || uv2.itemSize !== 2) {
+        geometry.setAttribute('uv2', copyVec2Attribute(uv));
+    }
+    return geometry;
+}
 export function csgGeometry(brush) {
-    return brush.geometry;
+    return ensureRenderableGeometryAttributes(brush.geometry);
 }
 export function csgMaterials(brush) {
     const mat = brush.material;
@@ -17,7 +76,7 @@ export function csgMaterials(brush) {
 export const csgEvaluator = new Evaluator();
 csgEvaluator.useGroups = true;
 csgEvaluator.consolidateGroups = false;
-csgEvaluator.attributes = ['position', 'normal', 'uv'];
+csgEvaluator.attributes = ['position', 'normal', 'uv', 'uv2'];
 export function computeGeometryBoundsTree(geometry) {
     ;
     geometry.computeBoundsTree =
@@ -25,9 +84,10 @@ export function computeGeometryBoundsTree(geometry) {
     geometry.computeBoundsTree({ maxLeafSize: 10 });
 }
 export function prepareBrushForCSG(brush) {
+    ensureRenderableGeometryAttributes(brush.geometry);
     computeGeometryBoundsTree(brush.geometry);
     brush.updateMatrixWorld();
 }
-// Re-export Brush + SUBTRACTION + ADDITION so kinds don't need a direct
-// `three-bvh-csg` dependency.
-export { ADDITION, Brush, SUBTRACTION } from 'three-bvh-csg';
+// 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/csg-utils.test.d.ts

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

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

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

package/dist/lib/csg-utils.test.js

@@ -0,0 +1,45 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import * as THREE from 'three';
+import { ensureRenderableGeometryAttributes } from './csg-utils';
+describe('ensureRenderableGeometryAttributes', () => {
+    test('fills missing render attributes to match position count', () => {
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]), 3));
+        ensureRenderableGeometryAttributes(geometry);
+        expect(geometry.getAttribute('position')?.count).toBe(3);
+        expect(geometry.getAttribute('normal')?.count).toBe(3);
+        expect(geometry.getAttribute('uv')?.count).toBe(3);
+        expect(geometry.getAttribute('uv2')?.count).toBe(3);
+    });
+    test('replaces render attributes with the wrong item size', () => {
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]), 3));
+        geometry.setAttribute('uv', new THREE.Float32BufferAttribute(new Float32Array([0, 0, 0]), 1));
+        geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(new Float32Array([0, 0, 0]), 1));
+        ensureRenderableGeometryAttributes(geometry);
+        expect(geometry.getAttribute('uv')?.itemSize).toBe(2);
+        expect(geometry.getAttribute('uv2')?.itemSize).toBe(2);
+        expect(geometry.getAttribute('uv')?.count).toBe(3);
+        expect(geometry.getAttribute('uv2')?.count).toBe(3);
+    });
+    test('copies uv into uv2 without depending on backing array layout', () => {
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]), 3));
+        geometry.setAttribute('uv', new THREE.InterleavedBufferAttribute(new THREE.InterleavedBuffer(new Float32Array([0, 0, 7, 1, 0, 8, 0, 1, 9]), 3), 2, 0));
+        ensureRenderableGeometryAttributes(geometry);
+        const uv2 = geometry.getAttribute('uv2');
+        expect(Array.from(uv2.array)).toEqual([0, 0, 1, 0, 0, 1]);
+    });
+    test('replaces empty geometries with a degenerate renderable triangle', () => {
+        const geometry = new THREE.BufferGeometry();
+        ensureRenderableGeometryAttributes(geometry);
+        expect(geometry.getIndex()).toBeNull();
+        expect(geometry.groups).toHaveLength(0);
+        expect(geometry.getAttribute('position')?.count).toBe(3);
+        expect(geometry.getAttribute('normal')?.count).toBe(3);
+        expect(geometry.getAttribute('uv')?.count).toBe(3);
+        expect(geometry.getAttribute('uv2')?.count).toBe(3);
+    });
+});

package/dist/lib/edge-style.d.ts

@@ -1,3 +1,4 @@
 export type EdgeMode = 'off' | 'soft' | 'strong';
 export declare function edgeColorFor(background: string): string;
+export declare function edgeOpacityScaleFor(background: string): number;
 //# sourceMappingURL=edge-style.d.ts.map

package/dist/lib/edge-style.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edge-style.d.ts","sourceRoot":"","sources":["../../src/lib/edge-style.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAA;AAKhD,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAOvD"}
+{"version":3,"file":"edge-style.d.ts","sourceRoot":"","sources":["../../src/lib/edge-style.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAA;AAgBhD,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAWvD;AAID,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE9D"}

package/dist/lib/edge-style.js

@@ -1,11 +1,31 @@
-// Ink line colour follows background luminance — light backgrounds get
-// near-black lines, dark backgrounds get near-white. Same rule Mapbox uses for
-// label outlines, so edges stay legible across every scene theme.
-export function edgeColorFor(background) {
+function lumaOf(background) {
     const hex = background.replace('#', '');
     const r = Number.parseInt(hex.slice(0, 2), 16) / 255;
     const g = Number.parseInt(hex.slice(2, 4), 16) / 255;
     const b = Number.parseInt(hex.slice(4, 6), 16) / 255;
-    const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
-    return luma > 0.5 ? '#1a1d24' : '#dde2eb';
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+// Ink line colour follows background luminance — light backgrounds get
+// near-black lines (the rule Mapbox uses for label outlines). Dark backgrounds
+// get a tint *derived from the background* rather than a near-white constant:
+// full-white lines glow harshly against night/twilight scenes, while lifting
+// the background's own hue toward white stays legible but reads native to the
+// theme.
+export function edgeColorFor(background) {
+    if (lumaOf(background) > 0.5)
+        return '#1a1d24';
+    const hex = background.replace('#', '');
+    let out = '#';
+    for (let i = 0; i < 3; i++) {
+        const c = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16) / 255;
+        out += Math.round((c + (1 - c) * 0.42) * 255)
+            .toString(16)
+            .padStart(2, '0');
+    }
+    return out;
+}
+// Dark scenes additionally run the ink slightly transparent — even a muted
+// tint at full alpha reads as glowing wireframe against a low-luma backdrop.
+export function edgeOpacityScaleFor(background) {
+    return lumaOf(background) > 0.5 ? 1 : 0.7;
 }

package/dist/lib/hero-pose.d.ts

@@ -0,0 +1,47 @@
+import { Box3 } from 'three';
+export declare const DEFAULT_FRAMING_EXCLUDED_TYPES: readonly ["site", "scan", "guide", "spawn"];
+export declare function heroCameraPose({ boxes, aspect, aim, fovDeg, azimuthRad, elevationRad, padding, minDistance, frameShift, }: {
+    boxes: Box3 | readonly Box3[];
+    aspect: number;
+    /** Where the camera looks (frame center). Defaults to the union-box center;
+     *  pass the building's center to keep it dead-center while outlying boxes
+     *  (lot plate, far palms) simply take asymmetric margin — the corner fit
+     *  still guarantees every box stays in frame. */
+    aim?: [number, number, number];
+    fovDeg?: number;
+    azimuthRad?: number;
+    elevationRad?: number;
+    padding?: number;
+    minDistance?: number;
+    /** Fraction of the frustum half-height to drop the aim by. 0 keeps the aim
+     *  (the building center) exactly at frame center. */
+    frameShift?: number;
+}): {
+    position: [number, number, number];
+    target: [number, number, number];
+};
+export declare function unionRegisteredNodeBounds({ excludeTypes, }: {
+    excludeTypes: readonly string[];
+}): Box3 | null;
+export type HeroFraming = {
+    /** Fit constraints — everything that must stay in frame. */
+    boxes: Box3[];
+    /** Frame center: plate/structure center on XZ, building center on Y. */
+    aim: [number, number, number];
+    /** 45° to the dominant facade (falls back to world 45°). */
+    azimuthRad: number;
+};
+/**
+ * Framing for a scene hero shot. The base set is the built structure (walls,
+ * roofs, slabs, …) plus any intentionally-shaped site plate; an item joins
+ * only when it sits near that base — one palm at the far lot corner must not
+ * shrink the building. `building`/`level` container groups are skipped (their
+ * Object3D holds the whole subtree). The aim keeps the building dead-center:
+ * XZ from the plate+structure union, Y from the structure alone so the
+ * building — not the ground — is vertically centered. Scenes with no
+ * structure (pure furniture arrangements) fall back to framing every
+ * non-helper node.
+ */
+export declare function computeHeroFraming(): HeroFraming | null;
+export declare function temporarilyHideNodeTypes(types: readonly string[]): () => void;
+//# sourceMappingURL=hero-pose.d.ts.map

package/dist/lib/hero-pose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hero-pose.d.ts","sourceRoot":"","sources":["../../src/lib/hero-pose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAA0B,MAAM,OAAO,CAAA;AAEpD,eAAO,MAAM,8BAA8B,6CAA8C,CAAA;AAEzF,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,MAAM,EACN,GAAG,EACH,MAAW,EACX,UAAwB,EACxB,YAAmC,EACnC,OAAc,EACd,WAAe,EACf,UAAc,GACf,EAAE;IACD,KAAK,EAAE,IAAI,GAAG,SAAS,IAAI,EAAE,CAAA;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd;;;qDAGiD;IACjD,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;yDACqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,GAAG;IACF,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC,CA2DA;AAED,wBAAgB,yBAAyB,CAAC,EACxC,YAAY,GACb,EAAE;IACD,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;CAChC,GAAG,IAAI,GAAG,IAAI,CAgBd;AAiFD,MAAM,MAAM,WAAW,GAAG;IACxB,4DAA4D;IAC5D,KAAK,EAAE,IAAI,EAAE,CAAA;IACb,wEAAwE;IACxE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,IAAI,WAAW,GAAG,IAAI,CAuCvD;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,IAAI,CAiB7E"}

package/dist/lib/hero-pose.js

@@ -0,0 +1,227 @@
+import { sceneRegistry, useScene } from '@pascal-app/core';
+import { Box3, Vector3 } from 'three';
+export const DEFAULT_FRAMING_EXCLUDED_TYPES = ['site', 'scan', 'guide', 'spawn'];
+export function heroCameraPose({ boxes, aspect, aim, fovDeg = 60, azimuthRad = Math.PI / 4, elevationRad = (13 * Math.PI) / 180, padding = 1.03, minDistance = 4, frameShift = 0, }) {
+    const list = Array.isArray(boxes) ? boxes : [boxes];
+    const union = new Box3();
+    for (const box of list)
+        union.union(box);
+    const center = aim ? new Vector3(aim[0], aim[1], aim[2]) : union.getCenter(new Vector3());
+    const tanVertical = Math.tan(((fovDeg / 2) * Math.PI) / 180);
+    const tanHorizontal = tanVertical * aspect;
+    // Camera basis for the chosen azimuth/elevation: `dir` points from the
+    // target toward the camera, `forward` is the view direction.
+    const dir = new Vector3(Math.sin(azimuthRad) * Math.cos(elevationRad), Math.sin(elevationRad), Math.cos(azimuthRad) * Math.cos(elevationRad));
+    const forward = dir.clone().negate();
+    const right = new Vector3().crossVectors(forward, new Vector3(0, 1, 0)).normalize();
+    const up = new Vector3().crossVectors(right, forward);
+    // Exact fit: for every corner of every per-node box, the minimal camera
+    // distance along `dir` that keeps it inside the frustum. Fitting the corners
+    // of the UNION box instead reads far too wide at a diagonal azimuth — the
+    // union AABB's extreme corners are the empty diamond tips nothing actually
+    // occupies. (A bounding-sphere fit is worse still for flat, spread scenes.)
+    const corner = new Vector3();
+    const offset = new Vector3();
+    let distance = minDistance;
+    for (const box of list) {
+        for (const x of [box.min.x, box.max.x]) {
+            for (const y of [box.min.y, box.max.y]) {
+                for (const z of [box.min.z, box.max.z]) {
+                    corner.set(x, y, z);
+                    offset.subVectors(corner, center);
+                    const lateral = offset.dot(right);
+                    const vertical = offset.dot(up);
+                    const depth = offset.dot(forward);
+                    distance = Math.max(distance, (Math.abs(lateral) / tanHorizontal - depth) * padding, (Math.abs(vertical) / tanVertical - depth) * padding);
+                }
+            }
+        }
+    }
+    // Reframe: slide aim and camera together along the view-up axis — pure
+    // composition shift, no perspective change.
+    const drop = up.clone().multiplyScalar(-frameShift * distance * tanVertical);
+    const target = center.clone().add(drop);
+    return {
+        position: [
+            target.x + dir.x * distance,
+            target.y + dir.y * distance,
+            target.z + dir.z * distance,
+        ],
+        target: [target.x, target.y, target.z],
+    };
+}
+export function unionRegisteredNodeBounds({ excludeTypes, }) {
+    const excluded = new Set(excludeTypes);
+    const result = new Box3();
+    for (const [type, ids] of Object.entries(sceneRegistry.byType)) {
+        if (excluded.has(type))
+            continue;
+        for (const id of ids) {
+            const object = sceneRegistry.nodes.get(id);
+            if (!object)
+                continue;
+            const bounds = new Box3().setFromObject(object);
+            if (!bounds.isEmpty())
+                result.union(bounds);
+        }
+    }
+    return result.isEmpty() ? null : result;
+}
+function perNodeBoxes(excludeTypes) {
+    const excluded = new Set(excludeTypes);
+    const boxes = [];
+    for (const [type, ids] of Object.entries(sceneRegistry.byType)) {
+        if (excluded.has(type))
+            continue;
+        for (const id of ids) {
+            const object = sceneRegistry.nodes.get(id);
+            if (!object)
+                continue;
+            const bounds = new Box3().setFromObject(object);
+            if (!bounds.isEmpty())
+                boxes.push(bounds);
+        }
+    }
+    return boxes;
+}
+/**
+ * Matches the `SiteNode` bootstrap polygon (a 30×30 square at the origin) —
+ * same rule as the editor's `computeSceneBoundsXZ`: an untouched default lot
+ * says nothing about the user's intent, so it shouldn't drive framing.
+ */
+function isDefaultSitePolygon(points) {
+    if (points.length !== 4)
+        return false;
+    const expected = [
+        [-15, -15],
+        [15, -15],
+        [15, 15],
+        [-15, 15],
+    ];
+    for (let i = 0; i < 4; i++) {
+        const p = points[i];
+        const e = expected[i];
+        if (!Array.isArray(p) || p.length < 2)
+            return false;
+        if (p[0] !== e[0] || p[1] !== e[1])
+            return false;
+    }
+    return true;
+}
+/** Flat boxes for intentionally-shaped site plates, from scene DATA — the
+ *  site's Object3D can't be measured (it carries the ±400 m horizon disc). */
+function sitePlateBoxes() {
+    const boxes = [];
+    for (const node of Object.values(useScene.getState().nodes)) {
+        if (node.type !== 'site')
+            continue;
+        const polygon = node.polygon;
+        const points = polygon?.points;
+        if (!Array.isArray(points) || isDefaultSitePolygon(points))
+            continue;
+        const box = new Box3();
+        for (const point of points) {
+            if (Array.isArray(point) && point.length >= 2) {
+                box.expandByPoint(new Vector3(Number(point[0]), 0, Number(point[1])));
+            }
+        }
+        if (!box.isEmpty())
+            boxes.push(box);
+    }
+    return boxes;
+}
+/** Dominant wall direction folded to a 90°-periodic axis (length-weighted
+ *  vector sum of 4θ), so the hero azimuth sits at a true 45° to the building's
+ *  facades no matter how the user rotated their plan. */
+function dominantWallYaw() {
+    let vx = 0;
+    let vz = 0;
+    for (const node of Object.values(useScene.getState().nodes)) {
+        if (node.type !== 'wall')
+            continue;
+        const { start, end } = node;
+        if (!(Array.isArray(start) && Array.isArray(end)))
+            continue;
+        const dx = Number(end[0]) - Number(start[0]);
+        const dz = Number(end[1]) - Number(start[1]);
+        const length = Math.hypot(dx, dz);
+        if (!(Number.isFinite(length) && length > 0.01))
+            continue;
+        const theta = Math.atan2(dz, dx);
+        vx += length * Math.cos(4 * theta);
+        vz += length * Math.sin(4 * theta);
+    }
+    if (vx === 0 && vz === 0)
+        return null;
+    return Math.atan2(vz, vx) / 4;
+}
+/**
+ * Framing for a scene hero shot. The base set is the built structure (walls,
+ * roofs, slabs, …) plus any intentionally-shaped site plate; an item joins
+ * only when it sits near that base — one palm at the far lot corner must not
+ * shrink the building. `building`/`level` container groups are skipped (their
+ * Object3D holds the whole subtree). The aim keeps the building dead-center:
+ * XZ from the plate+structure union, Y from the structure alone so the
+ * building — not the ground — is vertically centered. Scenes with no
+ * structure (pure furniture arrangements) fall back to framing every
+ * non-helper node.
+ */
+export function computeHeroFraming() {
+    const structural = perNodeBoxes([...DEFAULT_FRAMING_EXCLUDED_TYPES, 'item', 'building', 'level']);
+    if (structural.length === 0) {
+        const all = perNodeBoxes([...DEFAULT_FRAMING_EXCLUDED_TYPES, 'building', 'level']);
+        if (all.length === 0)
+            return null;
+        const union = new Box3();
+        for (const box of all)
+            union.union(box);
+        const center = union.getCenter(new Vector3());
+        return { boxes: all, aim: [center.x, center.y, center.z], azimuthRad: Math.PI / 4 };
+    }
+    const structuralUnion = new Box3();
+    for (const box of structural)
+        structuralUnion.union(box);
+    const plates = sitePlateBoxes();
+    const groundUnion = structuralUnion.clone();
+    for (const box of plates)
+        groundUnion.union(box);
+    const nearby = groundUnion
+        .clone()
+        .expandByVector(groundUnion.getSize(new Vector3()).multiplyScalar(0.15));
+    const boxes = [...structural, ...plates];
+    const itemIds = sceneRegistry.byType.item;
+    for (const id of itemIds) {
+        const object = sceneRegistry.nodes.get(id);
+        if (!object)
+            continue;
+        const bounds = new Box3().setFromObject(object);
+        if (!bounds.isEmpty() && nearby.intersectsBox(bounds))
+            boxes.push(bounds);
+    }
+    const groundCenter = groundUnion.getCenter(new Vector3());
+    const structuralCenter = structuralUnion.getCenter(new Vector3());
+    const yaw = dominantWallYaw();
+    return {
+        boxes,
+        aim: [groundCenter.x, structuralCenter.y, groundCenter.z],
+        azimuthRad: Math.PI / 4 - (yaw ?? 0),
+    };
+}
+export function temporarilyHideNodeTypes(types) {
+    const saved = new Map();
+    for (const type of types) {
+        const ids = sceneRegistry.byType[type];
+        ids.forEach((id) => {
+            const node = sceneRegistry.nodes.get(id);
+            if (node) {
+                saved.set(node, node.visible);
+                node.visible = false;
+            }
+        });
+    }
+    return () => {
+        saved.forEach((wasVisible, node) => {
+            node.visible = wasVisible;
+        });
+    };
+}

package/dist/lib/ink-edges.d.ts

@@ -3,7 +3,7 @@ export declare function inkedEdges({ depthTex, normalTex, inkColor, radius, opac
     normalTex: any;
     inkColor: any;
     radius: number;
-    opacity: number;
+    opacity: any;
     sceneRgb: any;
 }): any;
 //# sourceMappingURL=ink-edges.d.ts.map

package/dist/lib/ink-edges.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ink-edges.d.ts","sourceRoot":"","sources":["../../src/lib/ink-edges.ts"],"names":[],"mappings":"AA6BA,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,MAAM,EACN,OAAO,EACP,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,GAAG,CAAA;IACb,SAAS,EAAE,GAAG,CAAA;IACd,QAAQ,EAAE,GAAG,CAAA;IAIb,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,GAAG,CAAA;CACd,OAgCA"}
+{"version":3,"file":"ink-edges.d.ts","sourceRoot":"","sources":["../../src/lib/ink-edges.ts"],"names":[],"mappings":"AAoBA,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,MAAM,EACN,OAAO,EACP,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,GAAG,CAAA;IACb,SAAS,EAAE,GAAG,CAAA;IACd,QAAQ,EAAE,GAAG,CAAA;IAKb,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,GAAG,CAAA;IACZ,QAAQ,EAAE,GAAG,CAAA;CACd,OAsCA"}

package/dist/lib/ink-edges.js

@@ -1,4 +1,5 @@
-import { abs, colorToDirection, float, max, min, mix, screenSize, screenUV, smoothstep, vec2, } from 'three/tsl';
+import { abs, float, max, min, mix, screenSize, screenUV, smoothstep, vec2 } from 'three/tsl';
+import { unpackRGBToNormal } from './tsl-compat';
 // Screen-space ink outline (SketchUp / Moebius look). Reads the scene-pass
 // depth + normal MRT and inks two signals:
 //
@@ -29,15 +30,20 @@ export function inkedEdges({ depthTex, normalTex, inkColor, radius, opacity, sce
     const noiseGate = smoothstep(float(0.00002), float(0.00006), depthLap);
     // ≈ metres of step / near (near≈0.1): ~5cm starts a line, ~25cm solid.
     const depthEdge = smoothstep(float(0.5), float(2.5), depthMetric).mul(noiseGate);
-    const nC = colorToDirection(normalTex.sample(uvN)).normalize();
-    const nR = colorToDirection(normalTex.sample(uvN.add(vec2(px.x, 0)))).normalize();
-    const nL = colorToDirection(normalTex.sample(uvN.sub(vec2(px.x, 0)))).normalize();
-    const nU = colorToDirection(normalTex.sample(uvN.add(vec2(0, px.y)))).normalize();
-    const nD = colorToDirection(normalTex.sample(uvN.sub(vec2(0, px.y)))).normalize();
+    const nC = unpackRGBToNormal(normalTex.sample(uvN)).normalize();
+    const nR = unpackRGBToNormal(normalTex.sample(uvN.add(vec2(px.x, 0)))).normalize();
+    const nL = unpackRGBToNormal(normalTex.sample(uvN.sub(vec2(px.x, 0)))).normalize();
+    const nU = unpackRGBToNormal(normalTex.sample(uvN.add(vec2(0, px.y)))).normalize();
+    const nD = unpackRGBToNormal(normalTex.sample(uvN.sub(vec2(0, px.y)))).normalize();
+    // Ink is a near/mid-field affordance: fade it out with raw depth so the
+    // horizon (the infinite ground disc vanishing against the backdrop) and
+    // other far-field depth cliffs never draw a line across the sky junction.
+    // ~full ink below ≈150 m, none beyond ≈350 m (perspective near 0.1/far 1000).
+    const distanceFade = float(1).sub(smoothstep(float(0.9994), float(0.9998), dC));
     const nDiff = max(max(float(1).sub(nC.dot(nR)), float(1).sub(nC.dot(nL))), max(float(1).sub(nC.dot(nU)), float(1).sub(nC.dot(nD))));
     const normalEdge = smoothstep(float(0.01), float(0.05), nDiff);
     // TSL's typed overloads are finicky across versions; the runtime is proven in
     // the aesthetic sandbox, so cast at the mask/mix boundary.
-    const edgeMask = min(max(depthEdge, normalEdge).mul(opacity), float(1));
+    const edgeMask = min(max(depthEdge, normalEdge).mul(opacity).mul(distanceFade), float(1));
     return mix(sceneRgb, inkColor, edgeMask);
 }

package/dist/lib/ktx2-loader.d.ts

@@ -0,0 +1,46 @@
+import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader.js';
+/**
+ * KTX2Loader that survives block-misaligned textures. WebGPU rejects
+ * block-compressed textures whose base dimensions aren't multiples of 4;
+ * three's KTX2Loader only warns and transcodes anyway, and the resulting
+ * invalid texture poisons every render pass that binds it (endless
+ * "Invalid BindGroup … Invalid CommandBuffer" spam — baked GLBs carrying an
+ * odd-sized user-item texture triggered exactly this). Such payloads are
+ * routed to a fallback loader whose support flags report no compressed
+ * formats, which makes the transcoder emit plain RGBA32 — uncompressed
+ * textures have no alignment requirement.
+ */
+declare class AlignmentSafeKTX2Loader extends KTX2Loader {
+    private rgbaFallback;
+    private fallbackLoader;
+    /** Both `load()` and GLTFLoader's KHR_texture_basisu path funnel through
+     *  this internal — overriding it covers every entry point. */
+    _createTexture(buffer: ArrayBuffer, config?: Record<string, unknown>): Promise<unknown>;
+    dispose(): this;
+}
+/**
+ * Single shared KTX2 loader for the whole viewer — used both by the GLB loader
+ * (`use-gltf-ktx2`) and by catalog finish textures (`materials.ts`). KTX2 must
+ * be transcoded at load via the Basis WASM, and `detectSupport(renderer)` has to
+ * run once before any `.ktx2` is loaded so the loader picks a GPU format the
+ * device supports. `ensureKtx2Support` is idempotent per renderer and is called
+ * from the viewer root the moment the renderer is ready (even when no GLB is in
+ * the scene, so catalog `.ktx2` finishes still load).
+ */
+export declare const ktx2Loader: AlignmentSafeKTX2Loader;
+/**
+ * Resolves once `detectSupport` has succeeded for any renderer. `.ktx2` loads
+ * issued before that point would throw inside KTX2Loader ("Missing
+ * initialization with `.detectSupport( renderer )`"), so texture loaders await
+ * this instead of failing — covers materials created while the renderer is
+ * still initializing (e.g. a standalone capture canvas).
+ */
+export declare function whenKtx2Ready(): Promise<void>;
+/** Returns true once support has been detected for this renderer (KTX2 safe to load). */
+export declare function ensureKtx2Support(renderer: unknown): boolean;
+export declare function configureKtx2Support<T>(loader: {
+    setKTX2Loader: (ktx2: T) => unknown;
+}, renderer: unknown): boolean;
+export declare function isKtx2Url(url: string): boolean;
+export {};
+//# sourceMappingURL=ktx2-loader.d.ts.map

package/dist/lib/ktx2-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ktx2-loader.d.ts","sourceRoot":"","sources":["../../src/lib/ktx2-loader.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAA;AAwBrE;;;;;;;;;;GAUG;AACH,cAAM,uBAAwB,SAAQ,UAAU;IAC9C,OAAO,CAAC,YAAY,CAA0B;IAE9C,OAAO,CAAC,cAAc;IAkBtB;kEAC8D;IACxD,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAmC7F,OAAO,IAAI,IAAI;CAMhB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,yBAAgC,CAAA;AAWvD;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAE7C;AAED,yFAAyF;AACzF,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAkB5D;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,MAAM,EAAE;IAAE,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAA;CAAE,EAC/C,QAAQ,EAAE,OAAO,GAChB,OAAO,CAIT;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9C"}