@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/lib/backdrop.d.ts

@@ -1,3 +1,20 @@
+import { type ToneMapping } from 'three';
+import type { SceneTheme } from './scene-themes';
+/** Null explicitly removes the gradient; an omitted sky keeps the theme's derived atmosphere. */
+export declare function backdropColors(theme: Pick<SceneTheme, 'background' | 'backgroundSky' | 'appearance'>): {
+    background: string;
+    sky: string;
+    haze: string;
+    skyDeep: string;
+};
+/** Flat authored colours are display colours; only the foreground is exposed and tone mapped. */
+export declare function flatBackdropOutput({ background, foreground, alpha, toneMapping, outputColorSpace, }: {
+    background: any;
+    foreground: any;
+    alpha: any;
+    toneMapping: ToneMapping;
+    outputColorSpace: string;
+}): any;
 /**
  * Shared backdrop gradient: flat background looking down, a warm haze band
  * hugging the horizon, the theme sky arriving just above it and deepening

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

@@ -1 +1 @@
-{"version":3,"file":"backdrop.d.ts","sourceRoot":"","sources":["../../src/lib/backdrop.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,UAAU,EACV,IAAI,EACJ,GAAG,EACH,OAAO,GACR,EAAE;IACD,IAAI,EAAE,GAAG,CAAA;IACT,UAAU,EAAE,GAAG,CAAA;IACf,IAAI,EAAE,GAAG,CAAA;IACT,GAAG,EAAE,GAAG,CAAA;IACR,OAAO,EAAE,GAAG,CAAA;CACb,GAAG,GAAG,CAUN;AAMD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAWlF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAyChD"}
+{"version":3,"file":"backdrop.d.ts","sourceRoot":"","sources":["../../src/lib/backdrop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,OAAO,CAAA;AAEvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,iGAAiG;AACjG,wBAAgB,cAAc,CAC5B,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,GAAG,eAAe,GAAG,YAAY,CAAC;;;;;EASvE;AAED,iGAAiG;AACjG,wBAAgB,kBAAkB,CAAC,EACjC,UAAU,EACV,UAAU,EACV,KAAK,EACL,WAAW,EACX,gBAAgB,GACjB,EAAE;IACD,UAAU,EAAE,GAAG,CAAA;IACf,UAAU,EAAE,GAAG,CAAA;IACf,KAAK,EAAE,GAAG,CAAA;IACV,WAAW,EAAE,WAAW,CAAA;IACxB,gBAAgB,EAAE,MAAM,CAAA;CACzB,GAAG,GAAG,CAIN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,UAAU,EACV,IAAI,EACJ,GAAG,EACH,OAAO,GACR,EAAE;IACD,IAAI,EAAE,GAAG,CAAA;IACT,UAAU,EAAE,GAAG,CAAA;IACf,IAAI,EAAE,GAAG,CAAA;IACT,GAAG,EAAE,GAAG,CAAA;IACR,OAAO,EAAE,GAAG,CAAA;CACb,GAAG,GAAG,CAUN;AAMD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAWlF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAyChD"}

package/dist/lib/backdrop.js

@@ -1,4 +1,21 @@
-import { abs, exp, mix, smoothstep } from 'three/tsl';
+import { NoToneMapping } from 'three';
+import { abs, exp, mix, renderOutput, smoothstep, vec4 } from 'three/tsl';
+/** Null explicitly removes the gradient; an omitted sky keeps the theme's derived atmosphere. */
+export function backdropColors(theme) {
+    const sky = theme.backgroundSky ?? theme.background;
+    return {
+        background: theme.background,
+        sky,
+        haze: theme.backgroundSky === null ? theme.background : horizonHazeColor(sky, theme.appearance),
+        skyDeep: theme.backgroundSky === null ? theme.background : deepSkyColor(sky),
+    };
+}
+/** Flat authored colours are display colours; only the foreground is exposed and tone mapped. */
+export function flatBackdropOutput({ background, foreground, alpha, toneMapping, outputColorSpace, }) {
+    const backdrop = renderOutput(vec4(background, 1), NoToneMapping, outputColorSpace).rgb;
+    const scene = renderOutput(vec4(foreground, 1), toneMapping, outputColorSpace).rgb;
+    return vec4(mix(backdrop, scene, alpha), 1);
+}
 /**
  * Shared backdrop gradient: flat background looking down, a warm haze band
  * hugging the horizon, the theme sky arriving just above it and deepening

package/dist/lib/construction-dust.d.ts

@@ -0,0 +1,57 @@
+import type { Camera, Vector3 } from 'three';
+/**
+ * One pool for every puff on screen; a full pool reuses the oldest sprite. A big agent build
+ * (Victor run 11: 1,545 walls in 6 s) puffs about 2,000 sprites a lifetime.
+ */
+export declare const DUST_CAPACITY = 2048;
+/** A sprite never draws smaller than this on screen, so a whole-building view still shows its dust. */
+export declare const DUST_MIN_PX = 12;
+/** How long a sprite lives, in milliseconds. */
+export declare const DUST_LIFE_MS = 800;
+/**
+ * Construction dust as plain numbers: a fixed ring of sprites, each with its
+ * birth time, start point, velocity and size. Nothing allocates after
+ * construction. The ring order is the birth order, so the slot after the
+ * newest is always the oldest — the one a full pool gives up first.
+ */
+export declare class DustPool {
+    readonly capacity: number;
+    private readonly lifeMs;
+    private readonly born;
+    private readonly data;
+    private next;
+    private warmFrames;
+    private latestMs;
+    private lastEmitMs;
+    constructor(capacity?: number, lifeMs?: number);
+    /** Sprites alive at the latest time the pool has seen. */
+    get live(): number;
+    /** True when nothing emitted within a lifetime of `nowMs` can still be alive: a cheap idle check. */
+    quietAt(nowMs: number): boolean;
+    emit(x: number, y: number, z: number, vx: number, vy: number, vz: number, size: number, nowMs: number): void;
+    /**
+     * Advances to `nowMs`: expired sprites are dropped, and `write` receives
+     * every live one with its current position, size and opacity. Returns how
+     * many are alive.
+     */
+    step(nowMs: number, write: (slot: number, x: number, y: number, z: number, size: number, alpha: number) => void): number;
+    /**
+     * Asks the drawing side for a few frames of one invisible sprite: the first puff of a build would
+     * otherwise pay for the sprite material's first draw in the middle of the walls rising.
+     */
+    requestWarm(frames?: number): void;
+    /** One warm frame, if any is asked for. */
+    takeWarm(): boolean;
+    clear(): void;
+}
+/** A sprite's size in metres at `point`: its own, or DUST_MIN_PX on a screen `heightPx` tall. */
+export declare function dustSpriteSize(size: number, camera: Camera, heightPx: number, point: Vector3): number;
+/** A rising wall's puff: sprites along its base line, pushed out to either side. */
+export declare function emitAlongBase(pool: DustPool, from: Vector3, to: Vector3, nowMs: number): void;
+/**
+ * A landing's puff: sprites around the footprint `corners` (four points of
+ * its base, in order), pushed outwards. `strength` in [0, 1] scales the
+ * cloud, so a crate makes less dust than a column.
+ */
+export declare function emitAroundFoot(pool: DustPool, corners: readonly Vector3[], strength: number, nowMs: number): void;
+//# sourceMappingURL=construction-dust.d.ts.map

package/dist/lib/construction-dust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construction-dust.d.ts","sourceRoot":"","sources":["../../src/lib/construction-dust.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAyC,OAAO,EAAE,MAAM,OAAO,CAAA;AAEnF;;;GAGG;AACH,eAAO,MAAM,aAAa,OAAO,CAAA;AACjC,uGAAuG;AACvG,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B,gDAAgD;AAChD,eAAO,MAAM,YAAY,MAAM,CAAA;AAQ/B;;;;;GAKG;AACH,qBAAa,QAAQ;IACnB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,UAAU,CAA2B;IAE7C,YAAY,QAAQ,SAAgB,EAAE,MAAM,SAAe,EAK1D;IAED,0DAA0D;IAC1D,IAAI,IAAI,IAAI,MAAM,CAOjB;IAED,qGAAqG;IACrG,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE9B;IAED,IAAI,CACF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,QAed;IAED;;;;OAIG;IACH,IAAI,CACF,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GAC1F,MAAM,CAsBR;IAED;;;OAGG;IACH,WAAW,CAAC,MAAM,SAAI,QAErB;IAED,2CAA2C;IAC3C,QAAQ,IAAI,OAAO,CAIlB;IAED,KAAK,SAIJ;CACF;AAED,iGAAiG;AACjG,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,UAc5F;AAYD,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAsBtF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,QA+Cd"}

package/dist/lib/construction-dust.js

@@ -0,0 +1,187 @@
+/**
+ * One pool for every puff on screen; a full pool reuses the oldest sprite. A big agent build
+ * (Victor run 11: 1,545 walls in 6 s) puffs about 2,000 sprites a lifetime.
+ */
+export const DUST_CAPACITY = 2048;
+/** A sprite never draws smaller than this on screen, so a whole-building view still shows its dust. */
+export const DUST_MIN_PX = 12;
+/** How long a sprite lives, in milliseconds. */
+export const DUST_LIFE_MS = 800;
+/** Sprites slow down as the cloud spreads, rise a little, and grow as they thin out. */
+const DRAG_PER_S = 2.2;
+const RISE_M_PER_S = 0.25;
+const GROWTH = 1.8;
+const ALPHA = 0.42;
+/**
+ * Construction dust as plain numbers: a fixed ring of sprites, each with its
+ * birth time, start point, velocity and size. Nothing allocates after
+ * construction. The ring order is the birth order, so the slot after the
+ * newest is always the oldest — the one a full pool gives up first.
+ */
+export class DustPool {
+    capacity;
+    lifeMs;
+    born;
+    data;
+    next = 0;
+    warmFrames = 0;
+    latestMs = Number.NEGATIVE_INFINITY;
+    lastEmitMs = Number.NEGATIVE_INFINITY;
+    constructor(capacity = DUST_CAPACITY, lifeMs = DUST_LIFE_MS) {
+        this.capacity = capacity;
+        this.lifeMs = lifeMs;
+        this.born = new Float64Array(capacity).fill(Number.NEGATIVE_INFINITY);
+        this.data = new Float32Array(capacity * 7);
+    }
+    /** Sprites alive at the latest time the pool has seen. */
+    get live() {
+        let alive = 0;
+        for (let slot = 0; slot < this.capacity; slot += 1) {
+            const age = this.latestMs - this.born[slot];
+            if (age >= 0 && age < this.lifeMs)
+                alive += 1;
+        }
+        return alive;
+    }
+    /** True when nothing emitted within a lifetime of `nowMs` can still be alive: a cheap idle check. */
+    quietAt(nowMs) {
+        return nowMs - this.lastEmitMs >= this.lifeMs;
+    }
+    emit(x, y, z, vx, vy, vz, size, nowMs) {
+        const slot = this.next;
+        this.next = (slot + 1) % this.capacity;
+        this.latestMs = Math.max(this.latestMs, nowMs);
+        this.lastEmitMs = Math.max(this.lastEmitMs, nowMs);
+        this.born[slot] = nowMs;
+        const offset = slot * 7;
+        this.data[offset] = x;
+        this.data[offset + 1] = y;
+        this.data[offset + 2] = z;
+        this.data[offset + 3] = vx;
+        this.data[offset + 4] = vy;
+        this.data[offset + 5] = vz;
+        this.data[offset + 6] = size;
+    }
+    /**
+     * Advances to `nowMs`: expired sprites are dropped, and `write` receives
+     * every live one with its current position, size and opacity. Returns how
+     * many are alive.
+     */
+    step(nowMs, write) {
+        this.latestMs = Math.max(this.latestMs, nowMs);
+        let alive = 0;
+        for (let slot = 0; slot < this.capacity; slot += 1) {
+            const age = nowMs - this.born[slot];
+            if (!(age >= 0 && age < this.lifeMs))
+                continue;
+            const life = age / this.lifeMs;
+            const seconds = age / 1000;
+            // Distance travelled under linear drag: v·(1 − e^(−k·t))/k.
+            const travel = (1 - Math.exp(-DRAG_PER_S * seconds)) / DRAG_PER_S;
+            const offset = slot * 7;
+            write(alive, this.data[offset] + this.data[offset + 3] * travel, this.data[offset + 1] + this.data[offset + 4] * travel + RISE_M_PER_S * seconds, this.data[offset + 2] + this.data[offset + 5] * travel, this.data[offset + 6] * (1 + GROWTH * Math.sqrt(life)), ALPHA * (1 - life) ** 2);
+            alive += 1;
+        }
+        return alive;
+    }
+    /**
+     * Asks the drawing side for a few frames of one invisible sprite: the first puff of a build would
+     * otherwise pay for the sprite material's first draw in the middle of the walls rising.
+     */
+    requestWarm(frames = 3) {
+        this.warmFrames = Math.max(this.warmFrames, frames);
+    }
+    /** One warm frame, if any is asked for. */
+    takeWarm() {
+        if (this.warmFrames <= 0)
+            return false;
+        this.warmFrames -= 1;
+        return true;
+    }
+    clear() {
+        this.born.fill(Number.NEGATIVE_INFINITY);
+        this.next = 0;
+        this.lastEmitMs = Number.NEGATIVE_INFINITY;
+    }
+}
+/** A sprite's size in metres at `point`: its own, or DUST_MIN_PX on a screen `heightPx` tall. */
+export function dustSpriteSize(size, camera, heightPx, point) {
+    const metresPerPx = 'isOrthographicCamera' in camera
+        ? (camera.top - camera.bottom) /
+            camera.zoom /
+            heightPx
+        : 'isPerspectiveCamera' in camera
+            ? (2 *
+                camera.position.distanceTo(point) *
+                Math.tan((camera.fov * Math.PI) / 360)) /
+                camera.zoom /
+                heightPx
+            : 0;
+    return Math.max(size, DUST_MIN_PX * metresPerPx);
+}
+/** A fixed pseudo-random sequence: the same build puffs the same way, and tests stay stable. */
+let seed = 0x2f6b9d1;
+function random() {
+    seed = (Math.imul(seed ^ (seed >>> 15), 0x2c1b3c6d) + 0x6d2b79f5) | 0;
+    return ((seed >>> 0) % 100_000) / 100_000;
+}
+const PUFF_SPACING_M = 0.35;
+const MAX_PUFFS = 16;
+/** A rising wall's puff: sprites along its base line, pushed out to either side. */
+export function emitAlongBase(pool, from, to, nowMs) {
+    const dx = to.x - from.x;
+    const dz = to.z - from.z;
+    const length = Math.hypot(dx, dz);
+    const count = Math.max(3, Math.min(MAX_PUFFS, Math.round(length / PUFF_SPACING_M) + 1));
+    const nx = length > 1e-6 ? -dz / length : 1;
+    const nz = length > 1e-6 ? dx / length : 0;
+    for (let index = 0; index < count; index += 1) {
+        const along = (index + 0.25 + random() * 0.5) / count;
+        const side = random() < 0.5 ? -1 : 1;
+        const speed = 0.35 + random() * 0.45;
+        pool.emit(from.x + dx * along, from.y + (to.y - from.y) * along + 0.05, from.z + dz * along, side * nx * speed + (random() - 0.5) * 0.2, 0.08 + random() * 0.12, side * nz * speed + (random() - 0.5) * 0.2, 0.22 + random() * 0.14, nowMs);
+    }
+}
+/**
+ * A landing's puff: sprites around the footprint `corners` (four points of
+ * its base, in order), pushed outwards. `strength` in [0, 1] scales the
+ * cloud, so a crate makes less dust than a column.
+ */
+export function emitAroundFoot(pool, corners, strength, nowMs) {
+    let cx = 0;
+    let cy = 0;
+    let cz = 0;
+    let perimeter = 0;
+    for (let index = 0; index < corners.length; index += 1) {
+        const a = corners[index];
+        const b = corners[(index + 1) % corners.length];
+        cx += a.x / corners.length;
+        cy += a.y / corners.length;
+        cz += a.z / corners.length;
+        perimeter += Math.hypot(b.x - a.x, b.z - a.z);
+    }
+    const count = Math.max(4, Math.min(MAX_PUFFS, Math.round((perimeter / 0.5) * strength) + 4));
+    for (let index = 0; index < count; index += 1) {
+        // A point on the perimeter, at an even share of its length.
+        let along = ((index + random() * 0.6) / count) * perimeter;
+        let x = cx;
+        let z = cz;
+        for (let edge = 0; edge < corners.length; edge += 1) {
+            const a = corners[edge];
+            const b = corners[(edge + 1) % corners.length];
+            const span = Math.hypot(b.x - a.x, b.z - a.z);
+            if (along <= span || edge === corners.length - 1) {
+                const f = span > 1e-6 ? Math.min(1, along / span) : 0;
+                x = a.x + (b.x - a.x) * f;
+                z = a.z + (b.z - a.z) * f;
+                break;
+            }
+            along -= span;
+        }
+        const ox = x - cx;
+        const oz = z - cz;
+        const reach = Math.hypot(ox, oz) || 1;
+        const speed = (0.3 + random() * 0.4) * (0.5 + strength / 2);
+        pool.emit(x, cy + 0.04, z, (ox / reach) * speed, 0.05 + random() * 0.1, (oz / reach) * speed, (0.14 + random() * 0.12) * (0.6 + strength * 0.4), nowMs);
+    }
+}

package/dist/lib/csg-utils.js

@@ -81,7 +81,7 @@ export function computeGeometryBoundsTree(geometry) {
     ;
     geometry.computeBoundsTree =
         computeBoundsTree;
-    geometry.computeBoundsTree({ maxLeafSize: 10 });
+    geometry.computeBoundsTree({ targetLeafSize: 10 });
 }
 export function prepareBrushForCSG(brush) {
     ensureRenderableGeometryAttributes(brush.geometry);

package/dist/lib/display-state.d.ts

@@ -0,0 +1,25 @@
+import type { Discipline, DisplayFamily, DisplayMode } from '@pascal-app/core';
+/**
+ * Personal display state (F4, owner decision O3, frozen): kept per project in
+ * this browser like `showScans`, never shared with collaborators and never a
+ * geometry edit. Additive to `levelMode` / `wallMode`, which keep their
+ * meaning. It composes through a `display` layer-hold reason and never
+ * touches `object.visible`. Inside it `isolate` wins over `families`, which
+ * win over the mode default. "Save look" writes the project default to
+ * `site.presentation` (core `SitePresentation`); the canonical bake is
+ * independent of both. Not wired into the viewer store yet.
+ */
+export type DisplayState = {
+    mode: DisplayMode;
+    families?: Partial<Record<DisplayFamily, boolean>>;
+    disciplines: Record<Discipline, boolean>;
+    xray: boolean;
+    /** 0..1 presentation offset. */
+    separation: number;
+    colorBy: 'material' | 'service';
+    isolate?: {
+        kind: 'system' | 'owner';
+        id: string;
+    };
+};
+//# sourceMappingURL=display-state.d.ts.map

package/dist/lib/display-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-state.d.ts","sourceRoot":"","sources":["../../src/lib/display-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9E;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAA;IAClD,WAAW,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;IACxC,IAAI,EAAE,OAAO,CAAA;IACb,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,UAAU,GAAG,SAAS,CAAA;IAC/B,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAA;CACnD,CAAA"}

package/dist/lib/display-state.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/foundation-materials.d.ts

@@ -0,0 +1,26 @@
+import { MeshLambertNodeMaterial } from 'three/webgpu';
+/** The flat colour each structure reads as where only a colour is wanted (the cutaway palette). */
+export declare const STRUCTURE_COLORS: {
+    readonly cmu: "#97978f";
+    readonly concrete: "#8a8a86";
+};
+export type Masonry = {
+    course: number;
+    length: number;
+    joint: number;
+    colors: {
+        light: string;
+        dark: string;
+    };
+    mortar: string;
+};
+export declare const BLOCK_MASONRY: Masonry;
+/**
+ * Courses of running bond: each course half a unit over the one under it, mortar between. The
+ * courses are the world's (`positionWorld.y`), so a wall above a foundation bonds on its courses;
+ * `along` is the metres along the run, the foundation's own attribute by default, a wall's
+ * world-planar U where the geometry has none.
+ */
+export declare function masonryMaterial({ course: courseHeight, length, joint, colors, mortar }: Masonry, along?: any): MeshLambertNodeMaterial;
+export declare function concreteMaterial(): MeshLambertNodeMaterial;
+//# sourceMappingURL=foundation-materials.d.ts.map

package/dist/lib/foundation-materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foundation-materials.d.ts","sourceRoot":"","sources":["../../src/lib/foundation-materials.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAkBtD,mGAAmG;AACnG,eAAO,MAAM,gBAAgB;aAC3B,GAAG;aACH,QAAQ;CACA,CAAA;AAUV,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IACvC,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,OAM3B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAChE,KAAK,GAAE,GAA0C,2BAkBlD;AAED,wBAAgB,gBAAgB,4BAO/B"}

package/dist/lib/foundation-materials.js

@@ -0,0 +1,65 @@
+import { FrontSide } from 'three';
+import { attribute, color, float, floor, fract, mix, mod, mx_noise_float, normalLocal, positionWorld, smoothstep, step, vec3, } from 'three/tsl';
+import { MeshLambertNodeMaterial } from 'three/webgpu';
+/**
+ * How bare structure looks: courses of block, and cast concrete. The generic foundation under a
+ * building draws them (nodes `generic-foundation.tsx`), and a wall whose assembly has no cladding
+ * over a masonry or concrete core shows the same on its exterior face (`wall-materials.ts`), so a
+ * basement's walls above grade read as the foundation under them.
+ */
+const INCH = 0.0254;
+/** A nominal 8 × 8 × 16 in block: the course is 8 in with its joint, a block 16 in long. */
+const COURSE = 8 * INCH;
+const BLOCK_LENGTH = 16 * INCH;
+const JOINT = (3 / 8) * INCH;
+const JOINT_SOFTNESS = 0.05;
+const BLOCK_COLORS = { light: '#97978f', dark: '#827f78' };
+const MORTAR_COLOR = '#b5b3aa';
+const CONCRETE_COLORS = { light: '#8a8a86', dark: '#6f6e6a' };
+/** The flat colour each structure reads as where only a colour is wanted (the cutaway palette). */
+export const STRUCTURE_COLORS = {
+    cmu: BLOCK_COLORS.light,
+    concrete: CONCRETE_COLORS.light,
+};
+// TSL's own typings widen a float to a vec4 here, so the pieces are untyped.
+function jointMask(inside, joint) {
+    const edge = joint / 2;
+    return smoothstep(float(edge), float(edge + JOINT_SOFTNESS), inside).mul(smoothstep(float(edge), float(edge + JOINT_SOFTNESS), float(1).sub(inside)));
+}
+export const BLOCK_MASONRY = {
+    course: COURSE,
+    length: BLOCK_LENGTH,
+    joint: JOINT,
+    colors: BLOCK_COLORS,
+    mortar: MORTAR_COLOR,
+};
+/**
+ * Courses of running bond: each course half a unit over the one under it, mortar between. The
+ * courses are the world's (`positionWorld.y`), so a wall above a foundation bonds on its courses;
+ * `along` is the metres along the run, the foundation's own attribute by default, a wall's
+ * world-planar U where the geometry has none.
+ */
+export function masonryMaterial({ course: courseHeight, length, joint, colors, mortar }, along = attribute('along', 'float')) {
+    const material = new MeshLambertNodeMaterial({ side: FrontSide });
+    const rows = positionWorld.y.div(courseHeight);
+    const course = floor(rows);
+    const columns = along.div(length).add(mod(course, 2).mul(0.5));
+    const face = jointMask(fract(rows), joint / courseHeight).mul(jointMask(fract(columns), joint / length));
+    const shade = mx_noise_float(vec3(floor(columns), course, 0.5))
+        .mul(0.5)
+        .add(0.5);
+    const block = mix(color(colors.dark), color(colors.light), shade);
+    const patterned = mix(color(mortar), block, face);
+    // The top of a run is the plain block, whatever course the shader finds there.
+    const flat = step(float(0.5), normalLocal.y.abs());
+    material.colorNode = mix(patterned, block, flat);
+    return material;
+}
+export function concreteMaterial() {
+    const material = new MeshLambertNodeMaterial({ side: FrontSide });
+    const grain = mx_noise_float(positionWorld.mul(vec3(2.5, 2.5, 2.5)))
+        .mul(0.5)
+        .add(0.5);
+    material.colorNode = mix(color(CONCRETE_COLORS.dark), color(CONCRETE_COLORS.light), grain);
+    return material;
+}

package/dist/lib/gltf-unlit.d.ts

@@ -0,0 +1,10 @@
+import type { Material, Object3D } from 'three';
+export declare function importedUnlitMaterial(material: Material | null): boolean;
+/** Native basic materials still use AO; imported unlit assets already own their lighting. */
+export declare function preserveGltfUnlit(): {
+    name: string;
+    afterRoot({ scenes }: {
+        scenes: Object3D[];
+    }): null;
+};
+//# sourceMappingURL=gltf-unlit.d.ts.map

package/dist/lib/gltf-unlit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-unlit.d.ts","sourceRoot":"","sources":["../../src/lib/gltf-unlit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAQ,QAAQ,EAAE,MAAM,OAAO,CAAA;AAErD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAExE;AAED,6FAA6F;AAC7F,wBAAgB,iBAAiB;IAE7B,IAAI;IACJ,SAAS,aAAa;QAAE,MAAM,EAAE,QAAQ,EAAE,CAAA;KAAE;EAa/C"}

package/dist/lib/gltf-unlit.js

@@ -0,0 +1,23 @@
+export function importedUnlitMaterial(material) {
+    return material?.userData.pascalImportedUnlit === true;
+}
+/** Native basic materials still use AO; imported unlit assets already own their lighting. */
+export function preserveGltfUnlit() {
+    return {
+        name: 'PASCAL_imported_unlit',
+        afterRoot({ scenes }) {
+            for (const scene of scenes) {
+                scene.traverse((object) => {
+                    const mesh = object;
+                    if (!mesh.isMesh)
+                        return;
+                    for (const material of [mesh.material].flat()) {
+                        if ('isMeshBasicMaterial' in material)
+                            material.userData.pascalImportedUnlit = true;
+                    }
+                });
+            }
+            return null;
+        },
+    };
+}

package/dist/lib/ground-window.d.ts

@@ -0,0 +1,33 @@
+import { type AnyNode, type AnyNodeId, type GroundBox } from '@pascal-app/core';
+import type { Camera } from 'three';
+import { Vector3 } from 'three';
+/** Opens the window for `box` (kept with its margin), or closes it with `null`. */
+export declare function setGroundWindow(box: GroundBox | null): void;
+/** The box the window is currently open for, without its margin. */
+export declare function groundWindowBoxNow(): GroundBox | null;
+/** True while the window is open at all (the veil's word for "only in the window"). */
+export declare function groundWindowEnabledNode(): import("three/webgpu").Node<"bool">;
+/**
+ * True for a fragment the window veils: the ray from the eye through it goes on to meet the
+ * box (the fragment stands in front of the box, or inside it with box still beyond). The eye
+ * inside the box never veils: there the box's near planes are behind it.
+ */
+export declare function inGroundWindowNode(): import("three/webgpu").Node<"bool">;
+/** The mask solid ground draws with: everywhere but in the window. */
+export declare function groundWindowMaskNode(): import("three/webgpu").Node<"bool">;
+/**
+ * The CPU twin of {@link inGroundWindowNode} for one pick: whether `point`, seen from
+ * `origin`, is ground the window veils — so a click there falls through to what the window
+ * reveals, as a click on the wholesale veil does. `false` while the window is closed.
+ */
+export declare function groundWindowContains(origin: Vector3, point: Vector3): boolean;
+/**
+ * The window as one capture's own camera sees it, whatever the person's view holds: opened
+ * for the interior's floor, or the whole building, when ground stands between that camera
+ * and it — and closed when it does not, so a window open for the person's eye never leaks
+ * into a picture taken from the other side. The veil surfaces are stood up for the frame
+ * (the solid ground stays, its mask cut by the same window). The returned function gives
+ * the person's view back.
+ */
+export declare function temporarilyGroundWindowForCapture(camera: Camera, nodes: Record<AnyNodeId, AnyNode>, levelId?: string): () => void;
+//# sourceMappingURL=ground-window.d.ts.map

package/dist/lib/ground-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-window.d.ts","sourceRoot":"","sources":["../../src/lib/ground-window.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AACnC,OAAO,EAAa,OAAO,EAAE,MAAM,OAAO,CAAA;AAwB1C,mFAAmF;AACnF,wBAAgB,eAAe,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAiB3D;AAED,oEAAoE;AACpE,wBAAgB,kBAAkB,IAAI,SAAS,GAAG,IAAI,CAErD;AAED,uFAAuF;AACvF,wBAAgB,uBAAuB,wCAEtC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,wCAiBjC;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,wCAEnC;AAMD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAkB7E;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,IAAI,CAaZ"}

package/dist/lib/ground-window.js

@@ -0,0 +1,114 @@
+import { buildingGroundBox, levelGroundBox, terrainBetweenEyeAndBox, } from '@pascal-app/core';
+import { Box3, Ray, Vector3 } from 'three';
+import { cameraPosition, max, min, positionWorld, uniform, vec3 } from 'three/tsl';
+import { siteGround } from './site-surfaces';
+/**
+ * The ground window: where sculpted ground stands between the eye and the box that is shown
+ * (a level, or the whole building), that patch of ground is veiled and the rest stays solid.
+ * Decided per fragment here — a ray from the eye through the fragment that goes on to meet
+ * the box — because the patch's shape is exactly the box's silhouette against the hillside,
+ * which no CPU mesh rebuild could follow as cheaply. Whether the window opens at all is the
+ * CPU's word (`terrainBetweenEyeAndBox`, a handful of sight lines), read by the site renderer
+ * for the live view and by {@link temporarilyGroundWindowForCapture} for a picture, so both
+ * agree from their own cameras.
+ *
+ * One set of uniforms for the whole scene: there is one shown box at a time.
+ */
+const windowEnabled = uniform(0);
+const windowBoxMin = uniform(new Vector3());
+const windowBoxMax = uniform(new Vector3());
+let currentBox = null;
+/** The margin the window keeps around the box, so the house is not seen through a letterbox. */
+const WINDOW_MARGIN = 0.6;
+/** Opens the window for `box` (kept with its margin), or closes it with `null`. */
+export function setGroundWindow(box) {
+    currentBox = box;
+    if (!box) {
+        windowEnabled.value = 0;
+        return;
+    }
+    windowBoxMin.value.set(box.min[0] - WINDOW_MARGIN, box.min[1] - WINDOW_MARGIN, box.min[2] - WINDOW_MARGIN);
+    windowBoxMax.value.set(box.max[0] + WINDOW_MARGIN, box.max[1] + WINDOW_MARGIN, box.max[2] + WINDOW_MARGIN);
+    windowEnabled.value = 1;
+}
+/** The box the window is currently open for, without its margin. */
+export function groundWindowBoxNow() {
+    return currentBox;
+}
+/** True while the window is open at all (the veil's word for "only in the window"). */
+export function groundWindowEnabledNode() {
+    return windowEnabled.greaterThan(0.5);
+}
+/**
+ * True for a fragment the window veils: the ray from the eye through it goes on to meet the
+ * box (the fragment stands in front of the box, or inside it with box still beyond). The eye
+ * inside the box never veils: there the box's near planes are behind it.
+ */
+export function inGroundWindowNode() {
+    const toFragment = positionWorld.sub(cameraPosition);
+    const fragmentT = toFragment.length();
+    // The epsilon keeps an axis-aligned ray's reciprocal finite where a component is exactly 0.
+    const dir = toFragment.normalize().add(vec3(1e-6, 1e-6, 1e-6));
+    const invDir = vec3(1).div(dir);
+    const near = windowBoxMin.sub(cameraPosition).mul(invDir);
+    const far = windowBoxMax.sub(cameraPosition).mul(invDir);
+    const tMin = min(near, far);
+    const tMax = max(near, far);
+    const enter = max(max(tMin.x, tMin.y), tMin.z);
+    const exit = min(min(tMax.x, tMax.y), tMax.z);
+    return windowEnabled
+        .greaterThan(0.5)
+        .and(enter.greaterThan(0))
+        .and(enter.lessThanEqual(exit))
+        .and(exit.greaterThan(fragmentT));
+}
+/** The mask solid ground draws with: everywhere but in the window. */
+export function groundWindowMaskNode() {
+    return inGroundWindowNode().not();
+}
+const inflatedBox = new Box3();
+const scratchRay = new Ray();
+const scratchPoint = new Vector3();
+/**
+ * The CPU twin of {@link inGroundWindowNode} for one pick: whether `point`, seen from
+ * `origin`, is ground the window veils — so a click there falls through to what the window
+ * reveals, as a click on the wholesale veil does. `false` while the window is closed.
+ */
+export function groundWindowContains(origin, point) {
+    if (!currentBox)
+        return false;
+    inflatedBox.min.set(currentBox.min[0] - WINDOW_MARGIN, currentBox.min[1] - WINDOW_MARGIN, currentBox.min[2] - WINDOW_MARGIN);
+    inflatedBox.max.set(currentBox.max[0] + WINDOW_MARGIN, currentBox.max[1] + WINDOW_MARGIN, currentBox.max[2] + WINDOW_MARGIN);
+    if (inflatedBox.containsPoint(origin))
+        return false;
+    if (inflatedBox.containsPoint(point))
+        return true;
+    scratchRay.origin.copy(origin);
+    scratchRay.direction.copy(point).sub(origin).normalize();
+    const entry = scratchRay.intersectBox(inflatedBox, scratchPoint);
+    return entry !== null && entry.distanceTo(origin) >= point.distanceTo(origin) - 1e-4;
+}
+/**
+ * The window as one capture's own camera sees it, whatever the person's view holds: opened
+ * for the interior's floor, or the whole building, when ground stands between that camera
+ * and it — and closed when it does not, so a window open for the person's eye never leaks
+ * into a picture taken from the other side. The veil surfaces are stood up for the frame
+ * (the solid ground stays, its mask cut by the same window). The returned function gives
+ * the person's view back.
+ */
+export function temporarilyGroundWindowForCapture(camera, nodes, levelId) {
+    const previous = currentBox;
+    const box = levelId ? levelGroundBox(nodes, levelId) : buildingGroundBox(nodes);
+    const eye = [camera.position.x, camera.position.y, camera.position.z];
+    const open = box !== null && terrainBetweenEyeAndBox(nodes, eye, box);
+    setGroundWindow(open ? box : null);
+    const { veil } = siteGround();
+    const flipped = open ? veil.filter((surface) => !surface.visible) : [];
+    for (const surface of flipped)
+        surface.visible = true;
+    return () => {
+        for (const surface of flipped)
+            surface.visible = false;
+        setGroundWindow(previous);
+    };
+}