@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/lib/reveal-candidates.js

@@ -0,0 +1,524 @@
+import { isDerivedNode, nodeRegistry, } from '@pascal-app/core';
+/** A roof piece lifts this share of its drop before it falls: a hair, 20 cm of 4 m. */
+export const PART_LEAD = 0.05;
+/** `simple` keeps the stagger with only the two slice-one motions. */
+export function styleAt(style, at) {
+    // Framing lays a roof's covering over its frame in place; Full drops the whole roof.
+    if (at === 'framing')
+        return style === 'assemble' ? 'cover' : style;
+    if (at !== 'simple' || style === 'rise')
+        return style;
+    return 'scale';
+}
+/** Kinds that hold the others: staging one would unmount everything under it. */
+export const CONTAINERS = new Set(['site', 'building', 'level']);
+/**
+ * The reveal a new node of a kind that declares none comes in with, so nothing a build adds pops in
+ * at once: by where it stands (on an assembled node such as a roof, it falls onto it) and what it is. Null for the containers,
+ * the annotations and the kinds that draw nothing.
+ */
+function defaultReveal(node, nodes) {
+    const definition = nodeRegistry.get(node.type);
+    if (!definition || CONTAINERS.has(node.type))
+        return null;
+    if (definition.category === 'analysis' || !(definition.renderer || definition.geometry))
+        return null;
+    let parent = node.parentId ? nodes[node.parentId] : undefined;
+    for (let guard = 0; parent && guard < 32; guard += 1) {
+        if (nodeRegistry.get(parent.type)?.capabilities?.reveal?.style === 'assemble')
+            return { phase: 'roof', style: 'drop', height: 2 };
+        if (parent.type === 'level')
+            break;
+        parent = parent.parentId ? nodes[parent.parentId] : undefined;
+    }
+    switch (definition.category) {
+        case 'structure':
+            return { phase: 'structure', style: 'scale' };
+        case 'utility':
+            return { phase: 'openings', style: 'scale' };
+        case 'site':
+            return { phase: 'foundation', style: 'scale' };
+        default:
+            return { phase: 'furnishing', style: 'drop', height: 0.3 };
+    }
+}
+/** Whether `node` comes in with a new host the commit stages (it is drawn inside it), not on its own. */
+function ridesWithHost(node, before, current) {
+    const parent = node.parentId ? current.nodes[node.parentId] : undefined;
+    return Boolean(parent && !CONTAINERS.has(parent.type) && !before.nodes[parent.id]);
+}
+/** What a node declares and where it stands: its candidate, or null for a kind that declares no reveal. */
+function candidateOf(node, nodes, at, source, seq, fallback = false) {
+    const reveal = nodeRegistry.get(node.type)?.capabilities?.reveal ??
+        (fallback ? defaultReveal(node, nodes) : null);
+    if (!reveal)
+        return null;
+    let depth = 0;
+    let levelId = null;
+    let levelIndex = Number.MIN_SAFE_INTEGER;
+    let parent = node.parentId ? nodes[node.parentId] : undefined;
+    while (parent && depth < 32) {
+        depth += 1;
+        if (!levelId && parent.type === 'level') {
+            levelId = parent.id;
+            levelIndex = parent.level;
+        }
+        parent = parent.parentId ? nodes[parent.parentId] : undefined;
+    }
+    const style = styleAt(reveal.style, at);
+    const height = 'height' in reveal && style === reveal.style ? reveal.height : 0;
+    return {
+        id: node.id,
+        phase: reveal.phase,
+        levelId,
+        levelIndex,
+        source,
+        style,
+        height,
+        depth,
+        seq,
+    };
+}
+/**
+ * What `commit` stages at `at`: each node it creates whose kind declares a
+ * reveal, and the new parts (children declaring none) of each one that
+ * assembles. A new node of a kind that declares none comes in with a default
+ * reveal when what holds it was already there (under a new host, it comes in
+ * with the host). `seq` counts on from `firstSeq` in arrival order. Each
+ * candidate carries its room and its place in it (`layoutRevealCandidates`).
+ */
+export function commitRevealCandidates({ before, current, author }, at, firstSeq = 0) {
+    const candidates = [];
+    let seq = firstSeq;
+    for (const id in current.nodes) {
+        if (before.nodes[id])
+            continue;
+        const node = current.nodes[id];
+        const candidate = node &&
+            candidateOf(node, current.nodes, at, author ?? null, seq, !ridesWithHost(node, before, current));
+        if (!(node && candidate))
+            continue;
+        seq += 1;
+        candidates.push(candidate);
+        if (candidate.style !== 'assemble')
+            continue;
+        // Its new children that declare no reveal of their own are its parts: each drops in.
+        for (const partId of node.children ?? []) {
+            if (typeof partId !== 'string' || before.nodes[partId])
+                continue;
+            const part = current.nodes[partId];
+            if (!part || nodeRegistry.get(part.type)?.capabilities?.reveal)
+                continue;
+            candidates.push({
+                id: partId,
+                phase: candidate.phase,
+                levelId: candidate.levelId,
+                levelIndex: candidate.levelIndex,
+                source: candidate.source,
+                style: 'drop',
+                height: candidate.height,
+                depth: candidate.depth + 1,
+                seq: seq++,
+                host: id,
+                lead: PART_LEAD,
+            });
+        }
+    }
+    layoutRevealCandidates(candidates, current.nodes);
+    return candidates;
+}
+const isPt = (value) => Array.isArray(value) &&
+    value.length === 2 &&
+    typeof value[0] === 'number' &&
+    typeof value[1] === 'number';
+function polygonOf(node) {
+    const polygon = node.polygon;
+    return Array.isArray(polygon) && polygon.length >= 3 && polygon.every(isPt) ? polygon : null;
+}
+/** The room a node outlines, as its kind declares it (`capabilities.revealLayout.room`). */
+function roomOf(node) {
+    const polygon = nodeRegistry.get(node.type)?.capabilities?.revealLayout?.room?.(node);
+    return polygon && polygon.length >= 3 && polygon.every(isPt) ? polygon : null;
+}
+/** The line a node bounds rooms along, as its kind declares it (`capabilities.revealLayout.line`). */
+function lineOf(node) {
+    const line = nodeRegistry.get(node.type)?.capabilities?.revealLayout?.line?.(node);
+    return line && isPt(line[0]) && isPt(line[1]) ? line : null;
+}
+const middleOf = ([start, end]) => [
+    (start[0] + end[0]) / 2,
+    (start[1] + end[1]) / 2,
+];
+function centroidOf(polygon) {
+    let x = 0;
+    let z = 0;
+    for (const [px, pz] of polygon) {
+        x += px;
+        z += pz;
+    }
+    return [x / polygon.length, z / polygon.length];
+}
+function areaOf(polygon) {
+    let twice = 0;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const [x0, z0] = polygon[index];
+        const [x1, z1] = polygon[(index + 1) % polygon.length];
+        twice += x0 * z1 - x1 * z0;
+    }
+    return Math.abs(twice) / 2;
+}
+function inside([x, z], polygon) {
+    let within = false;
+    for (let index = 0, last = polygon.length - 1; index < polygon.length; last = index++) {
+        const [xi, zi] = polygon[index];
+        const [xj, zj] = polygon[last];
+        if (zi > z !== zj > z && x < ((xj - xi) * (z - zi)) / (zj - zi) + xi)
+            within = !within;
+    }
+    return within;
+}
+/** Where a node stands in its level's plan: a line's middle, a polygon's centre, a placed node's spot. */
+function planPointOf(node) {
+    const line = lineOf(node);
+    if (line)
+        return middleOf(line);
+    const { start, end, position } = node;
+    if (isPt(start) && isPt(end))
+        return middleOf([start, end]);
+    const polygon = polygonOf(node);
+    if (polygon)
+        return centroidOf(polygon);
+    if (Array.isArray(position) && typeof position[0] === 'number' && typeof position[2] === 'number')
+        return [position[0], position[2]];
+    return null;
+}
+/** The node right under the level that `id` stands in (itself, or the host it hangs on). */
+function standingOf(id, nodes) {
+    let node = nodes[id];
+    for (let guard = 0; node && guard < 32; guard += 1) {
+        const parent = node.parentId ? nodes[node.parentId] : undefined;
+        if (!parent || parent.type === 'level')
+            return node;
+        node = parent;
+    }
+    return null;
+}
+/** Walls a run holds before the next run of the same outline starts beside it. */
+const WALLS_PER_RUN = 6;
+/** Wall ends closer than this (m) meet. */
+const MEETS_M = 0.05;
+/**
+ * Gives each candidate its room for the lazy schedule: the room it stands in (a node on a line, the
+ * room on either side of its middle), else, for a node on a line, a run of the lines it meets end to
+ * end (`capabilities.revealLayout`); its room's
+ * sweep across the floor; and its place in the room (around the room's centre, or along the run).
+ * What stands in no room keeps none: it belongs to the floor.
+ */
+export function layoutRevealCandidates(candidates, nodes) {
+    const zonesByLevel = new Map();
+    const zonesOf = (levelId) => {
+        let zones = zonesByLevel.get(levelId);
+        if (zones)
+            return zones;
+        zones = [];
+        const level = nodes[levelId];
+        for (const childId of level?.children ?? []) {
+            const child = typeof childId === 'string' ? nodes[childId] : undefined;
+            const polygon = child ? roomOf(child) : null;
+            if (child && polygon)
+                zones.push({ id: child.id, polygon, centre: centroidOf(polygon) });
+        }
+        zones.sort((left, right) => areaOf(left.polygon) - areaOf(right.polygon));
+        zonesByLevel.set(levelId, zones);
+        return zones;
+    };
+    const turnAround = (centre, point) => {
+        const angle = Math.atan2(point[1] - centre[1], point[0] - centre[0]);
+        return angle < 0 ? angle + 2 * Math.PI : angle;
+    };
+    // Lines in no room, by level: they make runs; what they host follows them.
+    const loose = new Map();
+    const onLooseWalls = [];
+    for (const candidate of candidates) {
+        if (!candidate.levelId)
+            continue;
+        const standing = standingOf(candidate.host ?? candidate.id, nodes);
+        const point = standing && planPointOf(standing);
+        if (!(standing && point))
+            continue;
+        const zones = zonesOf(candidate.levelId);
+        const line = lineOf(standing);
+        let probes = [point];
+        if (line) {
+            const [start, end] = line;
+            const length = Math.hypot(end[0] - start[0], end[1] - start[1]) || 1;
+            const nx = -(end[1] - start[1]) / length;
+            const nz = (end[0] - start[0]) / length;
+            probes = [
+                [point[0] + nx * 0.3, point[1] + nz * 0.3],
+                [point[0] - nx * 0.3, point[1] - nz * 0.3],
+            ];
+        }
+        const zone = zones.find((candidateZone) => probes.some((probe) => inside(probe, candidateZone.polygon)));
+        if (zone) {
+            candidate.cluster = zone.id;
+            candidate.sweep = zone.centre[0] + zone.centre[1];
+            candidate.order = turnAround(zone.centre, point);
+            continue;
+        }
+        if (line && standing.id === candidate.id) {
+            const list = loose.get(candidate.levelId) ?? [];
+            list.push({ candidate, line });
+            loose.set(candidate.levelId, list);
+            continue;
+        }
+        if (line)
+            onLooseWalls.push({ candidate, wallId: standing.id, point });
+        candidate.order = point[0] + point[1];
+    }
+    for (const [levelId, walls] of loose)
+        layoutRuns(levelId, walls);
+    if (onLooseWalls.length === 0)
+        return;
+    const byId = new Map(candidates.map((candidate) => [candidate.id, candidate]));
+    for (const { candidate, wallId } of onLooseWalls) {
+        const wall = byId.get(wallId);
+        if (!wall?.cluster)
+            continue;
+        candidate.cluster = wall.cluster;
+        candidate.sweep = wall.sweep;
+        candidate.order = wall.order;
+    }
+}
+/** Lines in no room: the lines that meet end to end make an outline, cut in runs along it. */
+function layoutRuns(levelId, walls) {
+    const key = ([x, z]) => `${Math.round(x / MEETS_M)}:${Math.round(z / MEETS_M)}`;
+    const byEnd = new Map();
+    const ends = walls.map(({ line: [start, end] }) => [key(start), key(end)]);
+    ends.forEach((pair, index) => {
+        for (const end of pair)
+            byEnd.set(end, [...(byEnd.get(end) ?? []), index]);
+    });
+    const sweepOf = (index) => {
+        const [x, z] = middleOf(walls[index].line);
+        return x + z;
+    };
+    const meeting = (index) => ends[index].flatMap((end) => byEnd.get(end) ?? []).filter((next) => next !== index);
+    const seen = new Set();
+    const starts = walls
+        .map((_, index) => index)
+        .sort((left, right) => sweepOf(left) - sweepOf(right));
+    let outline = 0;
+    for (const first of starts) {
+        if (seen.has(first))
+            continue;
+        // An open chain is walked from one of its free ends, a closed outline from its first wall in
+        // the sweep: wall to the wall it meets, so each run is one stretch of the outline.
+        const component = new Set([first]);
+        for (const index of component)
+            for (const next of meeting(index))
+                component.add(next);
+        const begin = [...component]
+            .filter((index) => ends[index].some((end) => byEnd.get(end)?.length === 1))
+            .sort((left, right) => sweepOf(left) - sweepOf(right))[0] ?? first;
+        const order = [];
+        const stack = [begin];
+        while (stack.length > 0) {
+            const index = stack.pop();
+            if (seen.has(index))
+                continue;
+            seen.add(index);
+            order.push(index);
+            stack.push(...meeting(index).reverse());
+        }
+        order.forEach((index, rank) => {
+            const run = Math.floor(rank / WALLS_PER_RUN);
+            const candidate = walls[index].candidate;
+            candidate.cluster = `${levelId}:run:${outline}:${run}`;
+            candidate.sweep = sweepOf(order[run * WALLS_PER_RUN]);
+            candidate.order = rank;
+        });
+        outline += 1;
+    }
+}
+/** Moved less than this (metres, radians) and a piece is where it was. */
+const PLACED_EPSILON = 1e-4;
+function placedDifferently(was, now) {
+    if (typeof was === 'number' && typeof now === 'number')
+        return Math.abs(was - now) > PLACED_EPSILON;
+    if (Array.isArray(was) && Array.isArray(now)) {
+        return (was.length !== now.length || was.some((value, index) => placedDifferently(value, now[index])));
+    }
+    return was !== now;
+}
+/** Moved less than this (metres, radians) and a piece does not glide: it is where it was. */
+const GLIDES_FROM = 0.02;
+function placementOf(node) {
+    const { position, rotation } = node;
+    if (!(Array.isArray(position) && position.length === 3))
+        return null;
+    if (!position.every((value) => typeof value === 'number'))
+        return null;
+    const yaw = Array.isArray(rotation) ? rotation[1] : rotation;
+    return {
+        position: position,
+        yaw: typeof yaw === 'number' ? yaw : 0,
+    };
+}
+/** The place a piece glides from: standing in the same level both times, and moved enough to see. */
+function glidesFrom(was, node, nodes) {
+    if (was.parentId !== node.parentId || nodes[node.parentId]?.type !== 'level')
+        return null;
+    const from = placementOf(was);
+    const to = placementOf(node);
+    if (!(from && to))
+        return null;
+    const travelled = Math.hypot(from.position[0] - to.position[0], from.position[1] - to.position[1], from.position[2] - to.position[2]);
+    return travelled > GLIDES_FROM || Math.abs(from.yaw - to.yaw) > GLIDES_FROM ? from : null;
+}
+/**
+ * What `commit` moves: each piece of furniture it finds already there that is placed differently
+ * (another position, turn or parent). Furniture only, for now: walls and openings move with the
+ * rooms and walls that hold them.
+ */
+export function commitChangeCandidates({ before, current, author }, at, firstSeq = 0) {
+    const candidates = [];
+    let seq = firstSeq;
+    for (const id in current.nodes) {
+        const was = before.nodes[id];
+        const node = current.nodes[id];
+        if (!(was && node) || was === node)
+            continue;
+        if (nodeRegistry.get(node.type)?.capabilities?.reveal?.phase !== 'furnishing')
+            continue;
+        const placed = (value, key) => value[key];
+        const moved = node.parentId !== was.parentId ||
+            ['position', 'rotation'].some((key) => placedDifferently(placed(was, key), placed(node, key)));
+        if (!moved)
+            continue;
+        const candidate = candidateOf(node, current.nodes, at, author ?? null, seq);
+        if (!candidate)
+            continue;
+        seq += 1;
+        candidates.push({ ...candidate, from: glidesFrom(was, node, current.nodes) });
+    }
+    return candidates;
+}
+/**
+ * What taking `ids` back reveals: each of them, and everything under them (a wall's openings, a
+ * room's furniture), as the build would have staged it: by what its kind declares, or the default
+ * reveal a kind that declares none came in with. What stands in a host that goes (a segment of a
+ * stair, a part of a pool) goes with it; an assembled node (a roof) goes whole, not part by part.
+ */
+export function nodeRevealCandidates(ids, nodes, at) {
+    const asked = new Set(ids);
+    const seen = new Set();
+    const candidates = [];
+    const visit = (id, guard = 0) => {
+        const node = nodes[id];
+        if (!node || seen.has(id) || guard > 64)
+            return;
+        seen.add(id);
+        const host = node.parentId ? nodes[node.parentId] : undefined;
+        const goesWithHost = Boolean(host && !CONTAINERS.has(host.type) && (asked.has(host.id) || seen.has(host.id)));
+        const candidate = candidateOf(node, nodes, at, null, candidates.length, !goesWithHost);
+        if (candidate)
+            candidates.push(candidate);
+        // An assembled or covered node's parts are not staged on their own.
+        if (candidate?.style === 'assemble' || candidate?.style === 'cover')
+            return;
+        for (const childId of node.children ?? []) {
+            if (typeof childId === 'string')
+                visit(childId, guard + 1);
+        }
+    };
+    for (const id of asked)
+        visit(id);
+    return candidates;
+}
+/** How an edited node plays again: a quick re-rise or re-scale, never a fall from a height. */
+const EDIT_STYLE = {
+    rise: 'rise',
+    scale: 'scale',
+    settle: 'settle',
+    drop: 'scale',
+    cut: 'scale',
+    assemble: 'scale',
+    cover: 'scale',
+};
+const sameValue = (was, now) => Object.is(was, now) || JSON.stringify(was) === JSON.stringify(now);
+/**
+ * What `commit` edits: each node already there whose kind lists `capabilities.revealOnEdit` and one of
+ * those fields (the ones that make its picture) changed. A change to any other field stays instant, and
+ * so does what the structure reconciler derived from an edit (`derivedWrites`: the plates and ceilings it
+ * owns, the fields it wrote on a node): a wall moved does not make its room's floor rise again.
+ */
+export function commitEditCandidates({ before, current, author, derivedWrites }, at, firstSeq = 0) {
+    const candidates = [];
+    let seq = firstSeq;
+    for (const id in current.nodes) {
+        const was = before.nodes[id];
+        const node = current.nodes[id];
+        const derived = derivedWrites?.get(id);
+        if (!(was && node) || was === node || derived === 'all' || isDerivedNode(node))
+            continue;
+        const fields = nodeRegistry.get(node.type)?.capabilities?.revealOnEdit;
+        const edited = fields?.some((field) => !derived?.has(field) &&
+            !sameValue(was[field], node[field]));
+        if (!edited)
+            continue;
+        const candidate = candidateOf(node, current.nodes, at, author ?? null, seq, true);
+        if (!candidate)
+            continue;
+        seq += 1;
+        const style = EDIT_STYLE[candidate.style];
+        candidates.push({
+            ...candidate,
+            style,
+            height: style === candidate.style ? candidate.height : 0,
+            from: null,
+            edited: true,
+        });
+    }
+    return candidates;
+}
+/**
+ * What `commit` deletes that the picture can play out: each node that was there and is gone whose kind
+ * stages a reveal, as it was staged when built (a node standing in a host that goes with it goes with
+ * its host). Derived construction the reconciler retires is not a deletion the person or the agent made.
+ */
+export function commitDeleteCandidates({ before, current, author, derivedWrites }, at, firstSeq = 0) {
+    const candidates = [];
+    let seq = firstSeq;
+    // A plate or a ceiling the reconciler owns goes with its room: it plays when the commit takes a
+    // wall or a room off its level, and not when the reconciler merely derives it anew.
+    const goingLevels = new Set();
+    for (const id in before.nodes) {
+        const node = before.nodes[id];
+        if (current.nodes[id] || !node?.parentId)
+            continue;
+        if (nodeRegistry.get(node.type)?.capabilities?.revealLayout)
+            goingLevels.add(node.parentId);
+    }
+    for (const id in before.nodes) {
+        if (current.nodes[id])
+            continue;
+        const node = before.nodes[id];
+        if (!node)
+            continue;
+        if (isDerivedNode(node)) {
+            if (!(node.parentId && goingLevels.has(node.parentId)))
+                continue;
+        }
+        else if (derivedWrites?.get(id) === 'all')
+            continue;
+        const host = node.parentId ? before.nodes[node.parentId] : undefined;
+        const goesWithHost = Boolean(host && !CONTAINERS.has(host.type) && !current.nodes[host.id]);
+        const candidate = candidateOf(node, before.nodes, at, author ?? null, seq, !goesWithHost);
+        if (!candidate)
+            continue;
+        seq += 1;
+        candidates.push(candidate);
+    }
+    return candidates;
+}

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

@@ -0,0 +1,9 @@
+import type { Object3D } from 'three';
+/**
+ * Fades everything drawn under `root` to `opacity`. Idempotent: a frame later it only moves the
+ * opacity, and a renderer that put its own materials back is dressed again. At 1 it is whole.
+ */
+export declare function setGhost(root: Object3D, opacity: number): void;
+/** Gives every mesh under `root` its own materials and its shadow back. */
+export declare function clearGhost(root: Object3D): void;
+//# sourceMappingURL=reveal-ghost.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reveal-ghost.d.ts","sourceRoot":"","sources":["../../src/lib/reveal-ghost.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,QAAQ,EAAE,MAAM,OAAO,CAAA;AA+BrD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CA8B9D;AAED,2EAA2E;AAC3E,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAU/C"}

package/dist/lib/reveal-ghost.js

@@ -0,0 +1,62 @@
+const worn = new WeakMap();
+/** Under this a ghost casts no shadow and writes no depth: the rooms below are lit and seen. */
+const FAINT = 0.5;
+const cloneAll = (material) => Array.isArray(material) ? material.map((each) => each.clone()) : material.clone();
+const eachOf = (material) => Array.isArray(material) ? material : [material];
+function isMesh(object) {
+    return object.isMesh === true && Boolean(object.material);
+}
+/**
+ * Fades everything drawn under `root` to `opacity`. Idempotent: a frame later it only moves the
+ * opacity, and a renderer that put its own materials back is dressed again. At 1 it is whole.
+ */
+export function setGhost(root, opacity) {
+    if (opacity >= 0.999) {
+        clearGhost(root);
+        return;
+    }
+    root.traverse((child) => {
+        if (!isMesh(child))
+            return;
+        let entry = worn.get(child);
+        if (entry && child.material !== entry.ghost) {
+            // Its renderer set the real materials again: they are the originals now.
+            for (const material of eachOf(entry.ghost))
+                material.dispose();
+            entry = { original: child.material, ghost: cloneAll(child.material), cast: entry.cast };
+            worn.set(child, entry);
+            child.material = entry.ghost;
+        }
+        else if (!entry) {
+            entry = { original: child.material, ghost: cloneAll(child.material), cast: child.castShadow };
+            worn.set(child, entry);
+            child.material = entry.ghost;
+        }
+        for (const material of eachOf(entry.ghost)) {
+            // A material that turns transparent compiles anew once: the flag and the write order change.
+            if (!material.transparent) {
+                material.transparent = true;
+                material.needsUpdate = true;
+            }
+            material.opacity = opacity;
+            material.depthWrite = opacity > FAINT;
+        }
+        child.castShadow = opacity > FAINT && entry.cast;
+    });
+}
+/** Gives every mesh under `root` its own materials and its shadow back. */
+export function clearGhost(root) {
+    root.traverse((child) => {
+        if (!isMesh(child))
+            return;
+        const entry = worn.get(child);
+        if (!entry)
+            return;
+        if (child.material === entry.ghost)
+            child.material = entry.original;
+        for (const material of eachOf(entry.ghost))
+            material.dispose();
+        child.castShadow = entry.cast;
+        worn.delete(child);
+    });
+}

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

@@ -0,0 +1,12 @@
+import type { RevealCandidate } from './reveal-schedule';
+/**
+ * The nodes a construction reveal holds back until their turn, by id. Kept apart from the reveal
+ * component so the systems that build hosts read it without pulling in React.
+ */
+export declare const revealPending: Map<string, RevealCandidate>;
+/**
+ * Whether the node waits for its turn. A host builds without what waits in it: a wall cuts no
+ * hole for a window before the window's turn (Victor run 12).
+ */
+export declare function isRevealWaiting(id: string): boolean;
+//# sourceMappingURL=reveal-pending.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reveal-pending.d.ts","sourceRoot":"","sources":["../../src/lib/reveal-pending.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD;;;GAGG;AACH,eAAO,MAAM,aAAa,8BAAqC,CAAA;AAE/D;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEnD"}

package/dist/lib/reveal-pending.js

@@ -0,0 +1,12 @@
+/**
+ * The nodes a construction reveal holds back until their turn, by id. Kept apart from the reveal
+ * component so the systems that build hosts read it without pulling in React.
+ */
+export const revealPending = new Map();
+/**
+ * Whether the node waits for its turn. A host builds without what waits in it: a wall cuts no
+ * hole for a window before the window's turn (Victor run 12).
+ */
+export function isRevealWaiting(id) {
+    return revealPending.has(id);
+}