@pascal-app/viewer 0.9.1 → 0.9.2

package/dist/lib/backdrop.js

@@ -0,0 +1,92 @@
+import { abs, exp, mix, smoothstep } from 'three/tsl';
+/**
+ * Shared backdrop gradient: flat background looking down, a warm haze band
+ * hugging the horizon, the theme sky arriving just above it and deepening
+ * toward the zenith. One formula serves the post-processing backdrop and the
+ * thumbnail pipeline (per-pixel view ray) AND the site horizon disc's
+ * far-field dissolve (per-fragment view direction) — the disc converges to
+ * exactly this colour, so ground and backdrop meet without a seam from any
+ * camera pose.
+ *
+ * `dirY` is the world-space view direction's Y component (horizon = 0).
+ * Colour inputs are TSL nodes (uniforms or literals).
+ */
+export function backdropGradient({ dirY, background, haze, sky, skyDeep, }) {
+    // The pale sky arrives fast (full by ≈8° elevation) so eye-level frames
+    // actually show it, then deepens toward the zenith for a real gradient —
+    // a single pale stop reads as a white void with blue "hiding" up top.
+    let base = mix(background, sky, smoothstep(-0.02, 0.14, dirY));
+    base = mix(base, skyDeep, smoothstep(0.1, 0.55, dirY));
+    // Haze as an exponential glow hugging the horizon tightly: C¹-smooth on
+    // both sides, so it brightens the junction without ever drawing an edge.
+    const hazeWeight = exp(abs(dirY).mul(-11)).mul(0.8);
+    return mix(base, haze, hazeWeight);
+}
+// Warm sun tint the haze pulls toward — aerial perspective is sky-coloured
+// light plus a little sun scatter, not white fog.
+const HAZE_SUN_TINT = [255, 244, 222];
+/**
+ * Atmospheric haze at the horizon: the theme's *sky* colour pulled toward a
+ * warm sun tint — skyish and sunish at once, so the band reads as part of
+ * the sky rather than a white stripe. Dark themes keep it faint (a low glow
+ * over the night zenith).
+ */
+export function horizonHazeColor(sky, appearance) {
+    const amount = appearance === 'dark' ? 0.25 : 0.5;
+    const hex = sky.replace('#', '');
+    let out = '#';
+    for (let i = 0; i < 3; i++) {
+        const c = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+        out += Math.round(c + (HAZE_SUN_TINT[i] - c) * amount)
+            .toString(16)
+            .padStart(2, '0');
+    }
+    return out;
+}
+/**
+ * Zenith colour derived from the theme's sky: saturated and darkened in HSL
+ * so the hue stays the theme's own (blue studio, lavender sunset, near-black
+ * night) while the top of the frame gets real colour depth.
+ */
+export function deepSkyColor(sky) {
+    const hex = sky.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 max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = (max + min) / 2;
+    const d = max - min;
+    let h = 0;
+    let s = 0;
+    if (d > 0) {
+        s = d / (1 - Math.abs(2 * l - 1));
+        if (max === r)
+            h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+        else if (max === g)
+            h = ((b - r) / d + 2) / 6;
+        else
+            h = ((r - g) / d + 4) / 6;
+    }
+    const s2 = Math.min(1, s * 1.5 + 0.05);
+    const l2 = l * 0.72;
+    const c = (1 - Math.abs(2 * l2 - 1)) * s2;
+    const x = c * (1 - Math.abs(((h * 6) % 2) - 1));
+    const m = l2 - c / 2;
+    const sector = Math.floor(h * 6) % 6;
+    const rgb = [
+        [c, x, 0],
+        [x, c, 0],
+        [0, c, x],
+        [0, x, c],
+        [x, 0, c],
+        [c, 0, x],
+    ][sector];
+    let out = '#';
+    for (const channel of rgb) {
+        out += Math.round((channel + m) * 255)
+            .toString(16)
+            .padStart(2, '0');
+    }
+    return out;
+}

package/dist/lib/box-uv.d.ts

@@ -0,0 +1,13 @@
+import type { BoxGeometry } from 'three';
+/**
+ * Rewrite a default `BoxGeometry`'s UVs to world scale — 1 UV unit = 1 metre —
+ * so tiled finishes (with `repeat` in tiles-per-metre) render at a consistent
+ * real-world scale instead of stretching to fit each face. Matches the
+ * world-scale UV convention used by the procedural slab/wall geometry.
+ *
+ * three.js builds box faces in the fixed order [+X, -X, +Y, -Y, +Z, -Z], four
+ * verts each, with UVs spanning 0→1 across the face. Each face's two in-plane
+ * dimensions differ, so we scale U/V per face by that face's size in metres.
+ */
+export declare function applyWorldScaleBoxUVs(geometry: BoxGeometry, w: number, h: number, d: number): void;
+//# sourceMappingURL=box-uv.d.ts.map

package/dist/lib/box-uv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box-uv.d.ts","sourceRoot":"","sources":["../../src/lib/box-uv.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,OAAO,CAAA;AAExC;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,WAAW,EACrB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,IAAI,CAsBN"}

package/dist/lib/box-uv.js

@@ -0,0 +1,32 @@
+/**
+ * Rewrite a default `BoxGeometry`'s UVs to world scale — 1 UV unit = 1 metre —
+ * so tiled finishes (with `repeat` in tiles-per-metre) render at a consistent
+ * real-world scale instead of stretching to fit each face. Matches the
+ * world-scale UV convention used by the procedural slab/wall geometry.
+ *
+ * three.js builds box faces in the fixed order [+X, -X, +Y, -Y, +Z, -Z], four
+ * verts each, with UVs spanning 0→1 across the face. Each face's two in-plane
+ * dimensions differ, so we scale U/V per face by that face's size in metres.
+ */
+export function applyWorldScaleBoxUVs(geometry, w, h, d) {
+    const uv = geometry.getAttribute('uv');
+    if (!uv || uv.count < 24)
+        return; // non-default segmentation — leave as-is
+    // [uScaleMetres, vScaleMetres] per face, in three's face order.
+    const faceScale = [
+        [d, h], // +X
+        [d, h], // -X
+        [w, d], // +Y
+        [w, d], // -Y
+        [w, h], // +Z
+        [w, h], // -Z
+    ];
+    for (let face = 0; face < 6; face += 1) {
+        const [us, vs] = faceScale[face];
+        for (let v = 0; v < 4; v += 1) {
+            const i = face * 4 + v;
+            uv.setXY(i, uv.getX(i) * us, uv.getY(i) * vs);
+        }
+    }
+    uv.needsUpdate = true;
+}

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

@@ -1,16 +1,10 @@
-import type * as THREE from 'three';
+import * as THREE from 'three';
 import { type Brush, Evaluator } from 'three-bvh-csg';
-/**
- * Shared CSG primitives used by kinds whose geometry subtracts pieces
- * against their host (chimney trimmed by the roof shell, skylight
- * frame as a ring cut from a box, etc.). Lives in viewer because
- * three-bvh-csg + three-mesh-bvh are viewer-only deps; kinds living
- * in `@pascal-app/nodes` import these through the public surface.
- */
+export declare function ensureRenderableGeometryAttributes(geometry: THREE.BufferGeometry): THREE.BufferGeometry;
 export declare function csgGeometry(brush: Brush): THREE.BufferGeometry;
 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 { ADDITION, Brush, SUBTRACTION } from 'three-bvh-csg';
+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,KAAK,MAAM,OAAO,CAAA;AACnC,OAAO,EAAE,KAAK,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAGrD;;;;;;GAMG;AAEH,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,QAG9C;AAID,OAAO,EAAE,QAAQ,EAAE,KAAK,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;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"}

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/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,43 @@
+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 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,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9C"}

package/dist/lib/ktx2-loader.js

@@ -0,0 +1,136 @@
+import { DataTexture, LinearFilter, LinearMipmapLinearFilter, RGBAFormat, UnsignedByteType, } from 'three';
+// Deep path, NOT the `Addons.js` aggregate: the aggregate re-exports
+// LottieLoader/TTFLoader, whose CDN URL imports (`lottie-web`, `opentype.js`)
+// crash bun's test runtime for every consumer of the viewer barrel.
+import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader.js';
+/** Base width/height of a Basis-supercompressed KTX2 payload needing transcode
+ *  (vkFormat 0 = ETC1S/UASTC) whose dimensions aren't block-aligned, or null
+ *  for anything safe. Little-endian u32s: vkFormat at byte 12, pixelWidth at
+ *  20, pixelHeight at 24. */
+function readMisalignedBasisSize(buffer) {
+    if (buffer.byteLength < 28)
+        return null;
+    const view = new DataView(buffer);
+    const vkFormat = view.getUint32(12, true);
+    if (vkFormat !== 0)
+        return null;
+    const width = view.getUint32(20, true);
+    const height = view.getUint32(24, true);
+    return width % 4 !== 0 || height % 4 !== 0 ? { width, height } : null;
+}
+/**
+ * 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.
+ */
+class AlignmentSafeKTX2Loader extends KTX2Loader {
+    rgbaFallback = null;
+    fallbackLoader() {
+        if (!this.rgbaFallback) {
+            this.rgbaFallback = new KTX2Loader(this.manager);
+            this.rgbaFallback.setTranscoderPath(this.transcoderPath);
+            this.rgbaFallback.workerConfig = {
+                astcSupported: false,
+                astcHDRSupported: false,
+                etc1Supported: false,
+                etc2Supported: false,
+                dxtSupported: false,
+                bptcSupported: false,
+                pvrtcSupported: false,
+            };
+        }
+        return this.rgbaFallback;
+    }
+    /** Both `load()` and GLTFLoader's KHR_texture_basisu path funnel through
+     *  this internal — overriding it covers every entry point. */
+    async _createTexture(buffer, config) {
+        const misaligned = readMisalignedBasisSize(buffer);
+        if (misaligned) {
+            console.warn(`[viewer] KTX2 texture is ${misaligned.width}x${misaligned.height} (not multiple-of-4); ` +
+                'transcoding uncompressed so WebGPU can create it.');
+            const transcoded = (await this.fallbackLoader()._createTexture(buffer, config));
+            // The RGBA32 result still arrives as a CompressedTexture; three's WebGPU
+            // texture upload treats every CompressedTexture as block-compressed and
+            // crashes looking up a block descriptor for rgba8. Repackage the decoded
+            // pixels as a plain DataTexture instead.
+            const mip = transcoded.mipmaps?.[0];
+            if (!mip)
+                return transcoded;
+            const texture = new DataTexture(mip.data, mip.width, mip.height, RGBAFormat, UnsignedByteType);
+            texture.colorSpace = transcoded.colorSpace;
+            texture.generateMipmaps = true;
+            texture.minFilter = LinearMipmapLinearFilter;
+            texture.magFilter = LinearFilter;
+            texture.needsUpdate = true;
+            transcoded.dispose();
+            return texture;
+        }
+        return KTX2Loader.prototype._createTexture.call(this, buffer, config);
+    }
+    dispose() {
+        this.rgbaFallback?.dispose();
+        this.rgbaFallback = null;
+        super.dispose();
+        return 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 const ktx2Loader = new AlignmentSafeKTX2Loader();
+ktx2Loader.setTranscoderPath('https://cdn.jsdelivr.net/gh/pmndrs/drei-assets@master/basis/');
+const configuredRenderers = new WeakSet();
+const warnedRenderers = new WeakSet();
+let resolveKtx2Ready;
+const ktx2ReadyPromise = new Promise((resolve) => {
+    resolveKtx2Ready = resolve;
+});
+/**
+ * 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 function whenKtx2Ready() {
+    return ktx2ReadyPromise;
+}
+/** Returns true once support has been detected for this renderer (KTX2 safe to load). */
+export function ensureKtx2Support(renderer) {
+    const key = renderer;
+    if (!key)
+        return false;
+    if (configuredRenderers.has(key))
+        return true;
+    try {
+        ;
+        ktx2Loader.detectSupport(renderer);
+        configuredRenderers.add(key);
+        resolveKtx2Ready();
+        return true;
+    }
+    catch (error) {
+        // Some WebGPU flows can transiently call this before backend init; don't
+        // crash the scene — a later call (or the next render) retries.
+        if (!warnedRenderers.has(key)) {
+            console.warn('[viewer] Skipping KTX2 support detection for now.', error);
+            warnedRenderers.add(key);
+        }
+        return false;
+    }
+}
+export function isKtx2Url(url) {
+    return url.toLowerCase().endsWith('.ktx2');
+}

package/dist/lib/layers.d.ts

@@ -20,4 +20,14 @@ export declare const ZONE_LAYER = 2;
  * from thumbnails like the other editor-only layers.
  */
 export declare const GRID_LAYER = 3;
+/**
+ * Layer for geometry hidden from the color passes but still rendered into the
+ * shadow map ("shadow-caster-only"). Used when cutaway/solo views hide roofs
+ * or non-selected levels: the sun keeps casting their shadows, so interiors
+ * get window-shaped light patches instead of flooding with uniform sun.
+ * No camera or pass enables this layer — only each shadow-casting light's
+ * shadow camera does (see `lights.tsx`). Applied per-object (layers don't
+ * cascade) via `applyShadowOnly` / `clearShadowOnly` in `lib/shadow-only.ts`.
+ */
+export declare const SHADOW_ONLY_LAYER = 4;
 //# sourceMappingURL=layers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"layers.d.ts","sourceRoot":"","sources":["../../src/lib/layers.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,eAAO,MAAM,WAAW,IAAI,CAAA;AAE5B;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,IAAI,CAAA;AAE9B,oEAAoE;AACpE,eAAO,MAAM,UAAU,IAAI,CAAA;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,IAAI,CAAA"}
+{"version":3,"file":"layers.d.ts","sourceRoot":"","sources":["../../src/lib/layers.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,eAAO,MAAM,WAAW,IAAI,CAAA;AAE5B;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,IAAI,CAAA;AAE9B,oEAAoE;AACpE,eAAO,MAAM,UAAU,IAAI,CAAA;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,IAAI,CAAA;AAE3B;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,IAAI,CAAA"}

package/dist/lib/layers.js

@@ -20,3 +20,13 @@ export const ZONE_LAYER = 2;
  * from thumbnails like the other editor-only layers.
  */
 export const GRID_LAYER = 3;
+/**
+ * Layer for geometry hidden from the color passes but still rendered into the
+ * shadow map ("shadow-caster-only"). Used when cutaway/solo views hide roofs
+ * or non-selected levels: the sun keeps casting their shadows, so interiors
+ * get window-shaped light patches instead of flooding with uniform sun.
+ * No camera or pass enables this layer — only each shadow-casting light's
+ * shadow camera does (see `lights.tsx`). Applied per-object (layers don't
+ * cascade) via `applyShadowOnly` / `clearShadowOnly` in `lib/shadow-only.ts`.
+ */
+export const SHADOW_ONLY_LAYER = 4;