@pascal-app/viewer 1.0.4 → 1.0.5

package/dist/lib/reveal-schedule.js

@@ -0,0 +1,410 @@
+import { REVEAL_ARRIVAL } from './reveal-pose';
+export const REVEAL_PHASE_ORDER = [
+    'foundation',
+    'structure',
+    'circulation',
+    'openings',
+    'roof',
+    'furnishing',
+];
+/** The one place to tune the reveal's pace; the heights live in the kinds' declarations. */
+export const REVEAL_TIMING = {
+    nodeGapMs: 70,
+    groupGapMs: 280,
+    capMs: 6000,
+    durationMs: { rise: 650, scale: 400, settle: 380, drop: 620, cut: 260, assemble: 0 },
+};
+/**
+ * How long `style` moves its node in `table`. Only the Framing level's table has a `cover` time (it
+ * lays a roof's covering where Full drops the roof whole); a plan made on a Full table or the reverse
+ * play of a framing build gives a covering twice what the whole roof takes to come or go.
+ */
+export function styleMs(table, style) {
+    if (style !== 'cover')
+        return table[style];
+    return table.cover ?? 2 * (table.assemble > 0 ? table.assemble : table.drop);
+}
+export function revealGroupKey(candidate) {
+    return `${candidate.phase}:${candidate.levelId ?? ''}`;
+}
+/** A stable pseudo-random key from a node id (FNV-1a): a plan scatters the same way every time. */
+function scatterKey(id) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < id.length; index += 1) {
+        hash ^= id.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+/**
+ * Start times for `candidates`, from `startMs`. Phase after phase; within a phase every floor
+ * plays at once, its nodes in a scattered order (GSAP's stagger from "random") and evenly spaced,
+ * floors interleaved within one gap, so no frame starts a crowd. On a floor, what stands on
+ * something (a book on a shelf) starts after it.
+ */
+export function planReveal(candidates, startMs, timing = REVEAL_TIMING) {
+    const floorsByPhase = new Map();
+    for (const candidate of candidates) {
+        const floors = floorsByPhase.get(candidate.phase) ?? new Map();
+        floorsByPhase.set(candidate.phase, floors);
+        const floor = `${candidate.levelIndex}:${candidate.levelId ?? ''}`;
+        floors.set(floor, [...(floors.get(floor) ?? []), candidate]);
+    }
+    const planned = [];
+    let phaseStart = 0;
+    let end = 0;
+    let longest = 0;
+    for (const phase of REVEAL_PHASE_ORDER) {
+        const floors = floorsByPhase.get(phase);
+        if (!floors)
+            continue;
+        const lanes = [...floors.entries()].sort(([left], [right]) => left.localeCompare(right, undefined, { numeric: true }));
+        let phaseEnd = phaseStart;
+        lanes.forEach(([, nodes], lane) => {
+            const scattered = [...nodes].sort((left, right) => left.depth - right.depth ||
+                scatterKey(left.id) - scatterKey(right.id) ||
+                left.seq - right.seq);
+            scattered.forEach((candidate, index) => {
+                const offset = phaseStart + (index + lane / lanes.length) * timing.nodeGapMs;
+                planned.push({ candidate, offset });
+                phaseEnd = Math.max(phaseEnd, offset);
+                longest = Math.max(longest, styleMs(timing.durationMs, candidate.style));
+            });
+        });
+        end = phaseEnd;
+        phaseStart = phaseEnd + timing.groupGapMs;
+    }
+    const room = Math.max(0, timing.capMs - longest);
+    const compression = end > room ? room / end : 1;
+    const arrival = ({ candidate, offset }) => offset * compression +
+        styleMs(timing.durationMs, candidate.style) * REVEAL_ARRIVAL[candidate.style];
+    let finale = null;
+    for (const entry of planned) {
+        // Held still, an assembled node never arrives; its parts do.
+        if (entry.candidate.style === 'assemble')
+            continue;
+        if (!finale || arrival(entry) >= arrival(finale))
+            finale = entry;
+    }
+    return planned
+        .sort((left, right) => left.offset - right.offset || left.candidate.seq - right.candidate.seq)
+        .map((entry) => ({
+        ...entry.candidate,
+        group: revealGroupKey(entry.candidate),
+        startMs: startMs + entry.offset * compression,
+        ...(entry === finale ? { finale: true } : {}),
+    }));
+}
+/**
+ * The Framing level's pace: one factor on its whole timeline, the staging and the motions alike. 1 is
+ * the pace it was built at; 1.75 makes a build that took 20 s take 35 s, and anything smaller or
+ * larger takes proportionally longer. A pace of `p` multiplies every offset, gap, beat, duration and
+ * cap of this level (`LAZY_REVEAL_TIMING`) and of the frame each wall plays before it rises (Bones'
+ * `WALL_BUILD`), so pieces still snap and the build only plays out slower. The Full level reads
+ * `REVEAL_TIMING` and does not move with it.
+ */
+export const FRAMING_PACE = 1.75;
+/** The lazy schedule at pace 1; `LAZY_REVEAL_TIMING` is this at `FRAMING_PACE`. */
+export const LAZY_REVEAL_BASE_TIMING = {
+    floorOffsetMs: 1200,
+    roomOffsetMs: 420,
+    elementOffsetMs: {
+        foundation: 200,
+        structure: 360,
+        circulation: 260,
+        openings: 140,
+        roof: 180,
+        furnishing: 110,
+    },
+    phaseGapMs: 260,
+    jitter: 0.3,
+    capMs: 40_000,
+    durationMs: { rise: 760, scale: 520, settle: 640, drop: 820, cut: 320, assemble: 0, cover: 4200 },
+    coverMsPerM: 450,
+    coverMinMs: 1400,
+    overshoot: { rise: 0.7, scale: 1.6, settle: 1.6 },
+    minHeightM: { drop: 1.8, settle: 0.6 },
+};
+/** `timing` played at `pace` times its length: times scale, shares and heights do not. */
+export function pacedLazyTiming(timing, pace) {
+    const scaled = (table) => Object.fromEntries(Object.entries(table).map(([key, ms]) => [key, ms * pace]));
+    return {
+        ...timing,
+        floorOffsetMs: timing.floorOffsetMs * pace,
+        roomOffsetMs: timing.roomOffsetMs * pace,
+        elementOffsetMs: scaled(timing.elementOffsetMs),
+        phaseGapMs: timing.phaseGapMs * pace,
+        capMs: timing.capMs * pace,
+        durationMs: scaled(timing.durationMs),
+        coverMsPerM: timing.coverMsPerM * pace,
+        coverMinMs: timing.coverMinMs * pace,
+    };
+}
+/** The one place the lazy schedule and the framing level's motion are read from. */
+export const LAZY_REVEAL_TIMING = pacedLazyTiming(LAZY_REVEAL_BASE_TIMING, FRAMING_PACE);
+/**
+ * The person's animation speed: how fast the build animations play, as a multiple of today's.
+ * Higher is faster, so every time of a schedule is divided by it: ×2 plays a build in half the
+ * time, ×0.5 in twice as long. ×1 is every table exactly as shipped (the very same objects).
+ */
+export const ANIMATION_SPEEDS = [0.5, 0.75, 1, 1.5, 2];
+export const DEFAULT_ANIMATION_SPEED = 1;
+/** The step nearest to `value`; anything that is not a finite positive number is ×1. */
+export function normalizeAnimationSpeed(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+        return DEFAULT_ANIMATION_SPEED;
+    return ANIMATION_SPEEDS.reduce((best, step) => Math.abs(step - value) < Math.abs(best - value) ? step : best);
+}
+/** `timing` with every time divided by `speed`: durations, gaps and the cap. */
+export function pacedRevealTiming(timing, speed) {
+    return {
+        nodeGapMs: timing.nodeGapMs / speed,
+        groupGapMs: timing.groupGapMs / speed,
+        capMs: timing.capMs / speed,
+        durationMs: scaleTimes(timing.durationMs, 1 / speed),
+    };
+}
+/** `timing` with every time divided by `speed`; the share `speed` of its pace is not a time. */
+export function pacedRetractTiming(timing, speed) {
+    return {
+        ...timing,
+        nodeGapMs: timing.nodeGapMs / speed,
+        capMs: timing.capMs / speed,
+        durationMs: scaleTimes(timing.durationMs, 1 / speed),
+    };
+}
+function scaleTimes(table, factor) {
+    return Object.fromEntries(Object.entries(table).map(([key, ms]) => [key, ms === undefined ? ms : ms * factor]));
+}
+/** The Full level's schedule at `speed`; at ×1 it is `REVEAL_TIMING` itself. */
+export const revealTimingAt = (speed) => speed === 1 ? REVEAL_TIMING : pacedRevealTiming(REVEAL_TIMING, speed);
+/** The Framing level's schedule at `speed`; at ×1 it is `LAZY_REVEAL_TIMING` itself. */
+export const lazyTimingAt = (speed) => speed === 1 ? LAZY_REVEAL_TIMING : pacedLazyTiming(LAZY_REVEAL_BASE_TIMING, FRAMING_PACE / speed);
+/** The reverse play's schedule at `speed`; at ×1 it is `RETRACT_TIMING` itself. */
+export const retractTimingAt = (speed) => speed === 1 ? RETRACT_TIMING : pacedRetractTiming(RETRACT_TIMING, speed);
+/** A stable share in [0, 1) from an id: the same jitter every time. */
+function jitterKey(id) {
+    return (scatterKey(`${id}#jitter`) % 10_007) / 10_007;
+}
+const STAGE_A = ['foundation', 'structure', 'circulation', 'openings'];
+/**
+ * Start times for `candidates` on the lazy, nested schedule, from `startMs`:
+ * - each floor builds its foundation, structure, stairs and openings, a phase after the other, and
+ *   the floors go up side by side, `floorOffsetMs` apart;
+ * - in a phase, the rooms (`cluster`) start `roomOffsetMs` apart in their sweep order, and the
+ *   pieces of a room `elementOffsetMs` apart around it; what belongs to the whole floor comes first;
+ * - roofs come once every floor is up, then the furniture, floor by floor and room by room again;
+ * - a piece with a preroll starts after it (its plugin plays then), and its room's next phase waits.
+ * Every start is jittered. The plan grows with the build (its biggest room, its rooms, its floors),
+ * and is pulled together only past `capMs`. `startMs` of a planned entry is when the node itself
+ * moves; its preroll plays before.
+ */
+export function planLazyReveal(candidates, startMs, timing = LAZY_REVEAL_TIMING) {
+    const placed = [];
+    const floors = new Map();
+    for (const candidate of candidates) {
+        const floor = `${candidate.levelIndex}:${candidate.levelId ?? ''}`;
+        const list = floors.get(floor);
+        if (list)
+            list.push(candidate);
+        else
+            floors.set(floor, [candidate]);
+    }
+    const lanes = [...floors.entries()].sort(([left], [right]) => left.localeCompare(right, undefined, { numeric: true }));
+    const jittered = (id, offset) => (2 * jitterKey(id) - 1) * timing.jitter * offset;
+    /** Places one floor's nodes of one phase from `from`; returns when its last piece moves, or null. */
+    const placePhase = (nodes, phase, from) => {
+        if (nodes.length === 0)
+            return null;
+        const rooms = new Map();
+        for (const node of nodes) {
+            const room = node.cluster ?? '';
+            const list = rooms.get(room);
+            if (list)
+                list.push(node);
+            else
+                rooms.set(room, [node]);
+        }
+        const sweepOf = (members) => Math.min(...members.map((member) => member.sweep ?? Number.NEGATIVE_INFINITY));
+        const ordered = [...rooms.entries()].sort(([leftKey, left], [rightKey, right]) => 
+        // What belongs to the whole floor first, then the rooms in their sweep.
+        (leftKey === '' ? -1 : 0) - (rightKey === '' ? -1 : 0) ||
+            sweepOf(left) - sweepOf(right) ||
+            leftKey.localeCompare(rightKey));
+        const step = timing.elementOffsetMs[phase];
+        let last = from;
+        ordered.forEach(([room, members], index) => {
+            const roomStart = from +
+                index * timing.roomOffsetMs +
+                jittered(`${room}:${phase}`, index > 0 ? timing.roomOffsetMs : 0);
+            members.sort((left, right) => left.depth - right.depth ||
+                (left.order ?? 0) - (right.order ?? 0) ||
+                scatterKey(left.id) - scatterKey(right.id) ||
+                left.seq - right.seq);
+            members.forEach((candidate, rank) => {
+                const turn = Math.max(from, roomStart + rank * step + jittered(candidate.id, step));
+                const preroll = Math.max(0, candidate.prerollMs ?? 0);
+                placed.push({ candidate, motion: turn + preroll, preroll });
+                last = Math.max(last, turn + preroll);
+            });
+        });
+        return last;
+    };
+    const phaseOf = (nodes, phase) => nodes.filter((node) => node.phase === phase);
+    /** Every floor builds `phases` from `from`, `floorOffsetMs` apart; returns when the last piece moves. */
+    const stage = (phases, from) => {
+        let end = null;
+        let lane = 0;
+        for (const [, nodes] of lanes) {
+            const own = phases.flatMap((phase) => phaseOf(nodes, phase));
+            if (own.length === 0)
+                continue;
+            let cursor = from + lane * timing.floorOffsetMs;
+            lane += 1;
+            for (const phase of phases) {
+                const last = placePhase(phaseOf(nodes, phase), phase, cursor);
+                if (last === null)
+                    continue;
+                end = Math.max(end ?? last, last);
+                cursor = last + timing.phaseGapMs;
+            }
+        }
+        return end;
+    };
+    let cursor = 0;
+    for (const phases of [STAGE_A, ['roof'], ['furnishing']]) {
+        const end = stage(phases, cursor);
+        if (end !== null)
+            cursor = end + timing.phaseGapMs;
+    }
+    const longest = Math.max(0, ...placed.map(({ candidate }) => timing.durationMs[candidate.style]));
+    const lastMotion = Math.max(0, ...placed.map(({ motion }) => motion));
+    const room = Math.max(0, timing.capMs - longest);
+    const compression = lastMotion > room ? room / lastMotion : 1;
+    const arrival = ({ candidate, motion }) => motion * compression + timing.durationMs[candidate.style] * REVEAL_ARRIVAL[candidate.style];
+    let finale = null;
+    for (const entry of placed) {
+        if (entry.candidate.style === 'assemble')
+            continue;
+        if (!finale || arrival(entry) >= arrival(finale))
+            finale = entry;
+    }
+    return placed
+        .sort((left, right) => left.motion - right.motion || left.candidate.seq - right.candidate.seq)
+        .map((entry) => ({
+        ...entry.candidate,
+        group: revealGroupKey(entry.candidate),
+        startMs: startMs + entry.motion * compression,
+        ...(entry.preroll > 0 ? { prerollMs: entry.preroll * compression } : {}),
+        ...(entry === finale ? { finale: true } : {}),
+    }));
+}
+/** The one place to tune the reverse play's pace. */
+export const RETRACT_TIMING = {
+    speed: 0.62,
+    nodeGapMs: REVEAL_TIMING.nodeGapMs * 0.62,
+    capMs: 2400,
+    durationMs: { rise: 420, scale: 300, settle: 380, drop: 400, cut: 260, assemble: 520 },
+};
+/**
+ * The reverse play at the Framing level: the rewind's durations at the Framing pace, so a deleted
+ * floor comes apart as slowly as it went up. `capMs` keeps a whole floor's deconstruction in a
+ * bounded time however many pieces it takes back.
+ */
+/** A covering lifts off in this share of the time it took to lay. */
+export const COVER_REVERSE_SHARE = 0.6;
+export const LAZY_RETRACT_TIMING = {
+    speed: RETRACT_TIMING.speed,
+    nodeGapMs: RETRACT_TIMING.nodeGapMs * FRAMING_PACE,
+    capMs: 14_000,
+    durationMs: {
+        ...scaleTimes(RETRACT_TIMING.durationMs, FRAMING_PACE),
+        cover: LAZY_REVEAL_TIMING.durationMs.cover * COVER_REVERSE_SHARE,
+    },
+};
+/**
+ * How long a roof's covering takes by the size it covers at the Framing level at `speed`: its range
+ * in metres of sweep (`coverDurationMs`); `reverse` for the lifting off of a deletion or an undo.
+ */
+export function coverRangeAt(speed, reverse = false) {
+    const timing = lazyTimingAt(speed);
+    const share = reverse ? COVER_REVERSE_SHARE : 1;
+    return {
+        perMeterMs: timing.coverMsPerM * share,
+        minMs: timing.coverMinMs * share,
+        maxMs: timing.durationMs.cover * share,
+    };
+}
+/** The Framing level's reverse play at `speed`; at ×1 it is `LAZY_RETRACT_TIMING` itself. */
+export const lazyRetractTimingAt = (speed) => speed === 1 ? LAZY_RETRACT_TIMING : pacedRetractTiming(LAZY_RETRACT_TIMING, speed);
+/**
+ * The Framing build played backwards, for a deletion or an undo: the plan of the build (floor by
+ * floor, room by room, piece by piece, `planLazyReveal`) read from its end, so the furniture lifts
+ * out first, then the roof, the openings, the walls and the slabs last, and the floors come apart
+ * from the top down, each room as it went up. Each piece takes its own style's rewind time; a piece
+ * that had a preroll keeps it, after its own going, for the plugin that took it apart (a wall's
+ * boards come off and its studs fly up then). The whole ends within the cap by pulling the starts
+ * closer, never by skipping a piece.
+ */
+export function planLazyRetract(candidates, startMs, timing = LAZY_RETRACT_TIMING, build = LAZY_REVEAL_TIMING) {
+    const forward = planLazyReveal(candidates, 0, build);
+    const lastTurn = Math.max(0, ...forward.map((entry) => entry.startMs));
+    const placed = forward.map((entry) => ({
+        entry,
+        offset: (lastTurn - entry.startMs) * timing.speed,
+    }));
+    const longest = Math.max(0, ...placed.map(({ entry }) => styleMs(timing.durationMs, entry.style)));
+    const lastStart = Math.max(0, ...placed.map(({ offset }) => offset));
+    const room = Math.max(0, timing.capMs - longest);
+    const compression = lastStart > room ? room / lastStart : 1;
+    return placed
+        .map(({ entry, offset }) => {
+        const { startMs: _start, finale: _finale, prerollMs, ...candidate } = entry;
+        return {
+            ...candidate,
+            ...(prerollMs ? { prerollMs: prerollMs * timing.speed * compression } : {}),
+            startMs: startMs + offset * compression,
+            durationMs: styleMs(timing.durationMs, entry.style),
+        };
+    })
+        .sort((left, right) => left.startMs - right.startMs || right.seq - left.seq);
+}
+/**
+ * The build played backwards, for an undo: the last phase goes first and each goes after the one
+ * built on it (the furniture, the roof, the openings, the walls, the slab), and inside a phase the last
+ * piece to arrive is the first to go, so the plan reads one phase at a time as the build did. It is
+ * quicker; each piece takes its own style's rewind duration; and the whole ends within the cap by
+ * pulling the starts closer, never by skipping a piece.
+ */
+export function planRetract(candidates, startMs, timing = RETRACT_TIMING, build = REVEAL_TIMING) {
+    const forward = planReveal(candidates, 0, build);
+    const byPhase = new Map();
+    for (const entry of forward)
+        byPhase.set(entry.phase, [...(byPhase.get(entry.phase) ?? []), entry]);
+    const placed = [];
+    let cursor = 0;
+    for (const phase of [...REVEAL_PHASE_ORDER].reverse()) {
+        const entries = byPhase.get(phase);
+        if (!entries)
+            continue;
+        const first = Math.min(...entries.map((entry) => entry.startMs));
+        const last = Math.max(...entries.map((entry) => entry.startMs));
+        for (const entry of entries)
+            placed.push({ entry, offset: cursor + (last - entry.startMs) * timing.speed });
+        cursor += (last - first + build.groupGapMs) * timing.speed;
+    }
+    const longest = Math.max(0, ...placed.map(({ entry }) => styleMs(timing.durationMs, entry.style)));
+    const lastStart = Math.max(0, ...placed.map(({ offset }) => offset));
+    const room = Math.max(0, timing.capMs - longest);
+    const compression = lastStart > room ? room / lastStart : 1;
+    return placed
+        .map(({ entry, offset }) => {
+        const { startMs: _start, finale: _finale, ...candidate } = entry;
+        return {
+            ...candidate,
+            startMs: startMs + offset * compression,
+            durationMs: styleMs(timing.durationMs, entry.style),
+        };
+    })
+        .sort((left, right) => left.startMs - right.startMs || right.seq - left.seq);
+}

package/dist/lib/reveal-texture-scale.d.ts

@@ -0,0 +1,5 @@
+import { type Object3D } from 'three';
+/** Keep tiles per metre while a wall rises, without changing shared materials or cached geometry. */
+export declare function setRiseTextureScale(root: Object3D, scaleY: number, pivotY: number): void;
+export declare function clearRiseTextureScale(root: Object3D): void;
+//# sourceMappingURL=reveal-texture-scale.d.ts.map

package/dist/lib/reveal-texture-scale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal-texture-scale.d.ts","sourceRoot":"","sources":["../../src/lib/reveal-texture-scale.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAsEjF,qGAAqG;AACrG,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAmCxF;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAQ1D"}

package/dist/lib/reveal-texture-scale.js

@@ -0,0 +1,113 @@
+import { BufferAttribute, Mesh } from 'three';
+const geometryByRoot = new WeakMap();
+function verticalDerivatives(geometry, uv) {
+    const positions = geometry.getAttribute('position');
+    const vertical = new Float32Array(uv.count * 2);
+    if (!positions)
+        return vertical;
+    const count = geometry.index?.count ?? positions.count;
+    for (let offset = 0; offset + 2 < count; offset += 3) {
+        const first = geometry.index?.getX(offset) ?? offset;
+        const second = geometry.index?.getX(offset + 1) ?? offset + 1;
+        const third = geometry.index?.getX(offset + 2) ?? offset + 2;
+        const dy1 = positions.getY(second) - positions.getY(first);
+        const dy2 = positions.getY(third) - positions.getY(first);
+        const dx1 = positions.getX(second) - positions.getX(first);
+        const dx2 = positions.getX(third) - positions.getX(first);
+        const dz1 = positions.getZ(second) - positions.getZ(first);
+        const dz2 = positions.getZ(third) - positions.getZ(first);
+        const useX = Math.abs(dy1 * dx2 - dy2 * dx1) > Math.abs(dy1 * dz2 - dy2 * dz1);
+        const horizontal1 = useX ? dx1 : dz1;
+        const horizontal2 = useX ? dx2 : dz2;
+        const determinant = dy1 * horizontal2 - dy2 * horizontal1;
+        if (Math.abs(determinant) < 1e-10)
+            continue;
+        const du = ((uv.getX(second) - uv.getX(first)) * horizontal2 -
+            (uv.getX(third) - uv.getX(first)) * horizontal1) /
+            determinant;
+        const dv = ((uv.getY(second) - uv.getY(first)) * horizontal2 -
+            (uv.getY(third) - uv.getY(first)) * horizontal1) /
+            determinant;
+        for (const vertex of [first, second, third]) {
+            vertical[vertex * 2] = du;
+            vertical[vertex * 2 + 1] = dv;
+        }
+    }
+    return vertical;
+}
+function cloneDrawnGeometry(mesh) {
+    const original = mesh.geometry;
+    const channels = [];
+    for (const name of ['uv', 'uv1', 'uv2', 'uv3']) {
+        const attribute = original.getAttribute(name);
+        if (attribute instanceof BufferAttribute) {
+            const uv = attribute;
+            channels.push({
+                original: uv,
+                drawn: uv.clone(),
+                vertical: verticalDerivatives(original, uv),
+            });
+        }
+    }
+    if (channels.length === 0)
+        return null;
+    const drawn = original.clone();
+    let channel = 0;
+    for (const name of ['uv', 'uv1', 'uv2', 'uv3']) {
+        const attribute = original.getAttribute(name);
+        if (attribute instanceof BufferAttribute) {
+            const entry = channels[channel++];
+            if (entry)
+                drawn.setAttribute(name, entry.drawn);
+        }
+    }
+    mesh.geometry = drawn;
+    return { original, drawn, channels };
+}
+/** Keep tiles per metre while a wall rises, without changing shared materials or cached geometry. */
+export function setRiseTextureScale(root, scaleY, pivotY) {
+    let geometries = geometryByRoot.get(root);
+    if (!geometries) {
+        geometries = new Map();
+        geometryByRoot.set(root, geometries);
+    }
+    const owned = geometries;
+    root.traverse((object) => {
+        if (!(object instanceof Mesh))
+            return;
+        let entry = owned.get(object);
+        if (entry && object.geometry !== entry.drawn) {
+            entry.drawn.dispose();
+            owned.delete(object);
+            entry = undefined;
+        }
+        if (!entry) {
+            const cloned = cloneDrawnGeometry(object);
+            if (!cloned)
+                return;
+            entry = cloned;
+            owned.set(object, entry);
+        }
+        const positions = entry.original.getAttribute('position');
+        if (!positions)
+            return;
+        for (const channel of entry.channels) {
+            for (let vertex = 0; vertex < channel.original.count; vertex += 1) {
+                const shift = (scaleY - 1) * (positions.getY(vertex) - pivotY);
+                channel.drawn.setXY(vertex, channel.original.getX(vertex) + shift * (channel.vertical[vertex * 2] ?? 0), channel.original.getY(vertex) + shift * (channel.vertical[vertex * 2 + 1] ?? 0));
+            }
+            channel.drawn.needsUpdate = true;
+        }
+    });
+}
+export function clearRiseTextureScale(root) {
+    const geometries = geometryByRoot.get(root);
+    if (!geometries)
+        return;
+    for (const [mesh, entry] of geometries) {
+        if (mesh.geometry === entry.drawn)
+            mesh.geometry = entry.original;
+        entry.drawn.dispose();
+    }
+    geometryByRoot.delete(root);
+}

package/dist/lib/reveal-windows.d.ts

@@ -0,0 +1,23 @@
+import type { RevealPhase, SceneCommit } from '@pascal-app/core';
+import { type ConstructionRevealLevel } from './reveal-candidates';
+import { type RevealTiming } from './reveal-schedule';
+/** When one (phase, level) group of a reveal plays. */
+export type RevealWindow = {
+    phase: RevealPhase;
+    levelId: string | null;
+    /** When its first node starts, in ms from the reveal's first frame. */
+    startMs: number;
+    /** When its last node has finished moving in. */
+    endMs: number;
+};
+/**
+ * The (phase, level) windows `ConstructionReveal` plays for `commit` at
+ * `level`, as it plans them when nothing else is revealing, in ms from the
+ * reveal's first frame after the commit. For a presentation that plays beside
+ * the reveal (a plugin's own layer) and must land before a group ends.
+ *
+ * A second commit arriving mid-reveal is planned together with what is still
+ * waiting, so its real windows can shift from these.
+ */
+export declare function planRevealWindows(commit: SceneCommit, level?: ConstructionRevealLevel, timing?: RevealTiming): RevealWindow[];
+//# sourceMappingURL=reveal-windows.d.ts.map

package/dist/lib/reveal-windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal-windows.d.ts","sourceRoot":"","sources":["../../src/lib/reveal-windows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,KAAK,uBAAuB,EAA0B,MAAM,qBAAqB,CAAA;AAC1F,OAAO,EAGL,KAAK,YAAY,EAGlB,MAAM,mBAAmB,CAAA;AAE1B,uDAAuD;AACvD,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,WAAW,CAAA;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAA;IACf,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,KAAK,GAAE,uBAAgC,EACvC,MAAM,GAAE,YAA4B,GACnC,YAAY,EAAE,CAmBhB"}

package/dist/lib/reveal-windows.js

@@ -0,0 +1,31 @@
+import { commitRevealCandidates } from './reveal-candidates';
+import { planReveal, REVEAL_TIMING, revealGroupKey, styleMs, } from './reveal-schedule';
+/**
+ * The (phase, level) windows `ConstructionReveal` plays for `commit` at
+ * `level`, as it plans them when nothing else is revealing, in ms from the
+ * reveal's first frame after the commit. For a presentation that plays beside
+ * the reveal (a plugin's own layer) and must land before a group ends.
+ *
+ * A second commit arriving mid-reveal is planned together with what is still
+ * waiting, so its real windows can shift from these.
+ */
+export function planRevealWindows(commit, level = 'full', timing = REVEAL_TIMING) {
+    const windows = new Map();
+    for (const entry of planReveal(commitRevealCandidates(commit, level), 0, timing)) {
+        const endMs = entry.startMs + styleMs(timing.durationMs, entry.style);
+        const key = revealGroupKey(entry);
+        const window = windows.get(key);
+        if (!window) {
+            windows.set(key, {
+                phase: entry.phase,
+                levelId: entry.levelId,
+                startMs: entry.startMs,
+                endMs,
+            });
+            continue;
+        }
+        window.startMs = Math.min(window.startMs, entry.startMs);
+        window.endMs = Math.max(window.endMs, endMs);
+    }
+    return [...windows.values()];
+}

package/dist/lib/reveal-wipe.d.ts

@@ -0,0 +1,71 @@
+import type { RevealStyle } from '@pascal-app/core';
+import type { Object3D } from 'three';
+/**
+ * The covering of a node laid over what stands under it, in place: a roof at the Framing level
+ * keeps its frame and its shell is revealed continuously from its lowest edge to its highest, the
+ * way a wall's boards and finish go over its studs. Presentation only, like the pose: the scene is not
+ * touched, and the meshes wear masked clones of their materials while it plays (the scene's
+ * materials are shared and cached, so a wipe never writes to them).
+ *
+ * The sweep runs along the height when the node rises enough for that to read as eave to ridge, and
+ * along its longer plan side when it is flat.
+ */
+/**
+ * What a candidate is played as: a kind's declared style, or `cover`, which an `assemble` node
+ * plays at the Framing level (a roof holds still while its covering is laid over its frame). A
+ * kind never declares it, so it is the viewer's own and `RevealStyle` does not carry it.
+ */
+export type PlayedStyle = RevealStyle | 'cover';
+export type CoverAxis = 'x' | 'y' | 'z';
+/** Where the sweep starts and ends along its axis, in world metres. */
+export type CoverSweep = {
+    axis: CoverAxis;
+    from: number;
+    to: number;
+};
+/** A node that rises less than this (m) is flat: it sweeps along its longer plan side. */
+export declare const COVER_MIN_RISE_M = 0.6;
+type BoxLike = {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+/** The sweep of a node drawn inside `box` (world space). */
+export declare function coverSweepOf(box: BoxLike): CoverSweep;
+/**
+ * How long a covering takes by the size of what it covers, at a level's pace and the person's speed:
+ * `perMeterMs` for each metre of the sweep, never under `minMs` (a small porch roof does not crawl,
+ * it does not flash either) and never over `maxMs` (a long flat roof does not take half a minute).
+ */
+export type CoverRange = {
+    perMeterMs: number;
+    minMs: number;
+    maxMs: number;
+};
+/** The time a covering of `sweep` takes in `range`. */
+export declare function coverDurationMs(sweep: CoverSweep, range: CoverRange): number;
+/**
+ * How much of the sweep the covering has closed `elapsedMs` into `durationMs`, as a share in [0, 1].
+ * It moves continuously: an ease in and out (a sine), so it starts and stops without a jolt, and it
+ * is exactly 0 at the start and 1 at the end.
+ */
+export declare function coverShareAt(elapsedMs: number, durationMs: number): number;
+/**
+ * Shows what is below `at` (world metres along the sweep's axis) of everything drawn under `root`,
+ * and hides the rest. Idempotent: a frame later it only moves the level; a mesh whose renderer put
+ * its own materials back is dressed again. Cleared by `clearRevealWipe`.
+ */
+export declare function setRevealWipe(root: Object3D, sweep: CoverSweep, at: number): void;
+/** Gives every mesh under `root` its own materials and its shadow back. */
+export declare function clearRevealWipe(root: Object3D): void;
+/** The world coordinate the covering has reached on `root`, or null when it is not under a wipe. */
+export declare function revealWipeLevelOf(root: Object3D): number | null;
+export {};
+//# sourceMappingURL=reveal-wipe.d.ts.map

package/dist/lib/reveal-wipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal-wipe.d.ts","sourceRoot":"","sources":["../../src/lib/reveal-wipe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAkB,QAAQ,EAAE,MAAM,OAAO,CAAA;AAIrD;;;;;;;;;GASG;AAEH;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,OAAO,CAAA;AAE/C,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;AAEvC,uEAAuE;AACvE,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtE,0FAA0F;AAC1F,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAEnC,KAAK,OAAO,GAAG;IACb,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACxC,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CACzC,CAAA;AAED,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,CAUrD;AAED;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E,uDAAuD;AACvD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAG5E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAI1E;AAkCD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CA6BjF;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAWpD;AAED,oGAAoG;AACpG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CAE/D"}