@expofp/renderer 3.44.0 → 3.44.1

package/dist/controls/gestures.js

@@ -1,6 +1,7 @@
 import { useThree } from '@react-three/fiber';
 import { EventManager, Pan, Rotate, Tap } from 'mjolnir.js';
 import { useEffect } from 'react';
+import { hotState } from '../utils/hot-state';
 /**
  * Subscribes to one of the canvas's gestures for as long as the component is mounted.
  *
@@ -89,5 +90,9 @@ export function canvasPoint(event) {
 /**
  * The live recognizers by the element they listen on, so the handlers sharing a canvas share one.
  * Weak, so a canvas that goes away takes its entry with it.
+ *
+ * Kept across hot updates, because the ref count is the whole point of sharing: a fresh map would
+ * attach a second recognizer to a canvas that already has one, and every pan and pinch would be
+ * handled twice (see {@link hotState}).
  */
-const managers = new WeakMap();
+const managers = hotState(import.meta.hot, 'managers', () => new WeakMap());

package/dist/events/pointer.d.ts

@@ -1,13 +1,39 @@
+/**
+ * Picking: which def the pointer is on, and where on the plan.
+ *
+ * Two hooks are the way in — {@link usePointerProps} makes a layer's group interactive, and
+ * {@link usePickFilter} makes the canvas pick the way the renderer draws. Nothing outside this module
+ * calls anything else here; the rest is exported so the sibling spec can drive each piece on its own
+ * rather than through a mounted canvas.
+ */
 import { type RootState, type ThreeEvent } from '@react-three/fiber';
 import { type Intersection, type Object3D, type Ray, type Raycaster } from 'three';
 import { type PlanPoint, type Space } from '../space/Space';
 import { type LayerDef, type RenderableDef } from '../types/defs';
 import { type PointerHandlerName } from '../types/events';
 /**
- * Traces one mesh's intersection back to the def that drew it, or `undefined` when it cannot —
- * a slot released between the raycast and the dispatch, or a mesh whose picking is not implemented.
+ * What picking asks of a mesh's owner, in the owner's own terms — instances and defs, never
+ * intersections. Pulling the instance out of an intersection is this module's work, because the
+ * intersection is three's; a container only answers about what it allocated.
+ *
+ * One interface rather than two registrations, because both answers have one owner and arrive at one
+ * moment. `SlotContainer` satisfies it as it stands, so a container registers itself.
  */
-export type HitResolver = (hit: Intersection) => RenderableDef | undefined;
+export interface HitSource {
+    /**
+     * The def a mesh instance belongs to, or `undefined` when none does — an instance released between
+     * the raycast and the dispatch, or a mesh whose picking is not implemented.
+     * @param instance - The instance the mesh reported.
+     * @returns The def.
+     */
+    defAt(instance: number | undefined): RenderableDef | undefined;
+    /**
+     * Where a def sits in this mesh's draw order, counted from the one drawn first.
+     * @param def - The def to place.
+     * @returns Its place in the draw order.
+     */
+    paintOrderOf(def: RenderableDef): number;
+}
 /** The picking props {@link usePointerProps} builds for a layer's `<group>`. */
 export interface PointerGroupProps {
     /** Refuses the raycast traversal into the subtree while the layer is off screen. */
@@ -45,6 +71,17 @@ export interface PointerGroupProps {
  * @returns Props to spread onto the layer's `<group>`.
  */
 export declare function usePointerProps(layer: LayerDef, visible: boolean): PointerGroupProps;
+/**
+ * Makes the canvas pick the way the renderer draws, for as long as the component is mounted.
+ *
+ * R3F's `events.filter` is the one hook into picking that sees the whole hit list, which is why both
+ * corrections live there: {@link occludeHits} drops what hidden geometry stands in front of, and
+ * {@link orderCoplanarHits} settles what the depth buffer never ordered. Both are the renderer's own
+ * reading of its scene, so the whole arrangement is here rather than at whichever component mounts
+ * it — a caller wires picking by calling this, and nothing outside this module has to know that there
+ * are two halves or which order they run in.
+ */
+export declare function usePickFilter(): void;
 /**
  * Hands one of R3F's intersection events to a layer's handler, as the narrow event the public API
  * describes: the def that was hit, and where the pointer sits on the plan plane.
@@ -63,21 +100,17 @@ export declare function usePointerProps(layer: LayerDef, visible: boolean): Poin
  */
 export declare function dispatchPointer(layer: LayerDef, name: PointerHandlerName, event: ThreeEvent<MouseEvent>, space: Space): void;
 /**
- * Registers how a mesh's intersections map back to defs, for as long as the mesh is mounted.
- *
- * Each container knows two things no one else does: which field of an intersection identifies its
- * slot (`batchId` for a batched mesh, `instanceId` for an instanced one, the pack position for a line
- * batch), and which def holds that slot. It supplies both here as one closure, so the dispatch path
- * stays free of per-mesh-type knowledge.
- * @param mesh - The mesh whose hits the resolver speaks for.
- * @param resolve - Maps one of its intersections to a def.
- * @returns An unregister function, safe to call after another resolver replaced this one.
+ * Registers what speaks for a mesh's intersections, for as long as the mesh is mounted — so the
+ * dispatch and ordering paths stay free of per-mesh-type knowledge.
+ * @param mesh - The mesh whose hits the source speaks for.
+ * @param source - What answers for them.
+ * @returns An unregister function, safe to call after another source replaced this one.
  */
-export declare function registerHitResolver(mesh: Object3D, resolve: HitResolver): () => void;
+export declare function registerHitSource(mesh: Object3D, source: HitSource): () => void;
 /**
  * The def an intersection hit.
  *
- * A mesh with no registered resolver reports nothing, which is how a primitive whose picking is not
+ * A mesh with no registered source reports nothing, which is how a primitive whose picking is not
  * implemented behaves as if its layer were not interactive: the hit is dropped and no handler runs.
  * @param hit - The intersection to trace.
  * @returns The def, or `undefined` when the hit cannot be traced to one.
@@ -102,13 +135,14 @@ export declare function resolveHit(hit: Intersection): RenderableDef | undefined
 export declare function missedPoint(raycaster: Raycaster, scene: Object3D, space: Space): PlanPoint;
 /**
  * Drops the hits that geometry with no handlers hides, so a booth behind a wall or a model, opaque
- * or translucent, is not picked. R3F's `events.filter`, which runs on its nearest-first hits.
+ * or translucent, is not picked. The first half of R3F's `events.filter`, which runs on its
+ * nearest-first hits; {@link orderCoplanarHits} is the second, over what survives.
  *
  * R3F raycasts only interactive layers, so it cannot see what stands in front of them. This casts
  * the same ray at the whole scene and cuts the hits at the nearest object no interactive layer
  * holds. A wall and a logo on a booth's roof differ only in distance: the logo lies on the roof, and
- * the wall stands apart from it. So the cut keeps a hit up to {@link ELEVATION_PRECISION} behind
- * the occluder, the least separation at which the depth buffer draws two surfaces in order. Nearer
+ * the wall stands apart from it. So the cut keeps a hit up to {@link depthSeparation} behind the
+ * occluder, the least separation at which the depth buffer draws two surfaces in order. Nearer
  * than that, the occluder is drawn on the hit, not in front of it. A click with every hit dropped is
  * a miss, as a click on the occluder was before.
  * @param hits - R3F's hits, nearest first.
@@ -117,6 +151,31 @@ export declare function missedPoint(raycaster: Raycaster, scene: Object3D, space
  * @returns The hits in front of the nearest occluder.
  */
 export declare function occludeHits(hits: Intersection[], state: RootState, space: Space): Intersection[];
+/**
+ * Reorders the hits the depth buffer never separated, so the one drawn last is picked first. R3F's
+ * `events.filter`, after {@link occludeHits} has cut away what is hidden.
+ *
+ * Three sorts its intersections by distance alone, and two coplanar polygons are not at two
+ * distances — they are at one distance the ray-triangle math resolves a little differently for each
+ * of them. Which one R3F dispatches first is that float noise, so a click on the overlap selects
+ * one shape on one frame and its neighbor on the next. Sorting stably does not help: the distances
+ * genuinely differ rather than tying, and the order three produced them in is a mesh's free list,
+ * which `SlotContainer` keeps deliberately apart from paint order.
+ *
+ * So the tie is settled by what the user is already looking at. Hits within
+ * {@link depthSeparation} of the nearest of their run are one depth, because that is the separation
+ * below which the depth buffer stops ordering surfaces and draw order alone decides what is on top
+ * — the same rule {@link occludeHits} cuts by. Within a run they are ordered by where they draw,
+ * last first, along the three keys three's own painter sort reads in the same order: the layer
+ * group they hang under, the batch's place in that layer, then the instance's place in the batch.
+ *
+ * A run is measured from its own first hit rather than from the hit before it, so a stack of
+ * surfaces each just inside the separation is still cut into runs instead of chaining into one.
+ * @param hits - R3F's hits, nearest first.
+ * @param space - The scene's space, whose scale turns the plan-unit separation into a world one.
+ * @returns The hits in pick order.
+ */
+export declare function orderCoplanarHits(hits: Intersection[], space: Space): Intersection[];
 /**
  * Where a ray crosses the plan plane — the floor under the pointer, whatever is drawn above it.
  *

package/dist/events/pointer.js

@@ -1,5 +1,16 @@
-import { ELEVATION_PRECISION } from '../space/clipping';
+/**
+ * Picking: which def the pointer is on, and where on the plan.
+ *
+ * Two hooks are the way in — {@link usePointerProps} makes a layer's group interactive, and
+ * {@link usePickFilter} makes the canvas pick the way the renderer draws. Nothing outside this module
+ * calls anything else here; the rest is exported so the sibling spec can drive each piece on its own
+ * rather than through a mounted canvas.
+ */
+import { useThree } from '@react-three/fiber';
+import { useEffect } from 'react';
+import { depthSeparation } from '../space/clipping';
 import { useSpace } from '../space/Space';
+import { hotState } from '../utils/hot-state';
 /**
  * The props that make a layer's group interactive: one dispatching handler per handler the def
  * declares, and the raycast gate that un-picks the layer while it is off screen.
@@ -41,6 +52,31 @@ export function usePointerProps(layer, visible) {
         onPointerOut: handlesPointerOut ? handler('onPointerOut') : undefined,
     };
 }
+/**
+ * Makes the canvas pick the way the renderer draws, for as long as the component is mounted.
+ *
+ * R3F's `events.filter` is the one hook into picking that sees the whole hit list, which is why both
+ * corrections live there: {@link occludeHits} drops what hidden geometry stands in front of, and
+ * {@link orderCoplanarHits} settles what the depth buffer never ordered. Both are the renderer's own
+ * reading of its scene, so the whole arrangement is here rather than at whichever component mounts
+ * it — a caller wires picking by calling this, and nothing outside this module has to know that there
+ * are two halves or which order they run in.
+ */
+export function usePickFilter() {
+    const setEvents = useThree((state) => state.setEvents);
+    // Picking is reported on the plan, and R3F casts its rays in world coordinates.
+    const space = useSpace();
+    useEffect(() => {
+        setEvents({
+            filter: (hits, state) => {
+                // Cut first, then order: dropping what is hidden cannot move the survivors along the ray,
+                // and ordering hits that were about to be dropped is work for nothing.
+                const visible = occludeHits(hits, state, space);
+                return orderCoplanarHits(visible, space);
+            },
+        });
+    }, [setEvents, space]);
+}
 /**
  * Hands one of R3F's intersection events to a layer's handler, as the narrow event the public API
  * describes: the def that was hit, and where the pointer sits on the plan plane.
@@ -78,33 +114,29 @@ export function dispatchPointer(layer, name, event, space) {
     });
 }
 /**
- * Registers how a mesh's intersections map back to defs, for as long as the mesh is mounted.
- *
- * Each container knows two things no one else does: which field of an intersection identifies its
- * slot (`batchId` for a batched mesh, `instanceId` for an instanced one, the pack position for a line
- * batch), and which def holds that slot. It supplies both here as one closure, so the dispatch path
- * stays free of per-mesh-type knowledge.
- * @param mesh - The mesh whose hits the resolver speaks for.
- * @param resolve - Maps one of its intersections to a def.
- * @returns An unregister function, safe to call after another resolver replaced this one.
+ * Registers what speaks for a mesh's intersections, for as long as the mesh is mounted — so the
+ * dispatch and ordering paths stay free of per-mesh-type knowledge.
+ * @param mesh - The mesh whose hits the source speaks for.
+ * @param source - What answers for them.
+ * @returns An unregister function, safe to call after another source replaced this one.
  */
-export function registerHitResolver(mesh, resolve) {
-    resolvers.set(mesh, resolve);
+export function registerHitSource(mesh, source) {
+    sources.set(mesh, source);
     return () => {
-        if (resolvers.get(mesh) === resolve)
-            resolvers.delete(mesh);
+        if (sources.get(mesh) === source)
+            sources.delete(mesh);
     };
 }
 /**
  * The def an intersection hit.
  *
- * A mesh with no registered resolver reports nothing, which is how a primitive whose picking is not
+ * A mesh with no registered source reports nothing, which is how a primitive whose picking is not
  * implemented behaves as if its layer were not interactive: the hit is dropped and no handler runs.
  * @param hit - The intersection to trace.
  * @returns The def, or `undefined` when the hit cannot be traced to one.
  */
 export function resolveHit(hit) {
-    return resolvers.get(hit.object)?.(hit);
+    return sources.get(hit.object)?.defAt(hit.instanceId);
 }
 /**
  * Where a missed click landed, in plan units.
@@ -131,13 +163,14 @@ export function missedPoint(raycaster, scene, space) {
 }
 /**
  * Drops the hits that geometry with no handlers hides, so a booth behind a wall or a model, opaque
- * or translucent, is not picked. R3F's `events.filter`, which runs on its nearest-first hits.
+ * or translucent, is not picked. The first half of R3F's `events.filter`, which runs on its
+ * nearest-first hits; {@link orderCoplanarHits} is the second, over what survives.
  *
  * R3F raycasts only interactive layers, so it cannot see what stands in front of them. This casts
  * the same ray at the whole scene and cuts the hits at the nearest object no interactive layer
  * holds. A wall and a logo on a booth's roof differ only in distance: the logo lies on the roof, and
- * the wall stands apart from it. So the cut keeps a hit up to {@link ELEVATION_PRECISION} behind
- * the occluder, the least separation at which the depth buffer draws two surfaces in order. Nearer
+ * the wall stands apart from it. So the cut keeps a hit up to {@link depthSeparation} behind the
+ * occluder, the least separation at which the depth buffer draws two surfaces in order. Nearer
  * than that, the occluder is drawn on the hit, not in front of it. A click with every hit dropped is
  * a miss, as a click on the occluder was before.
  * @param hits - R3F's hits, nearest first.
@@ -155,9 +188,62 @@ export function occludeHits(hits, state, space) {
     if (!occluder)
         return hits;
     // Along the ray, a pitched view only lengthens the gap between two surfaces, never shortens it.
-    const cut = occluder.distance + ELEVATION_PRECISION * space.scale;
+    const cut = occluder.distance + depthSeparation(space.scale);
     return hits.filter((hit) => hit.distance <= cut);
 }
+/**
+ * Reorders the hits the depth buffer never separated, so the one drawn last is picked first. R3F's
+ * `events.filter`, after {@link occludeHits} has cut away what is hidden.
+ *
+ * Three sorts its intersections by distance alone, and two coplanar polygons are not at two
+ * distances — they are at one distance the ray-triangle math resolves a little differently for each
+ * of them. Which one R3F dispatches first is that float noise, so a click on the overlap selects
+ * one shape on one frame and its neighbor on the next. Sorting stably does not help: the distances
+ * genuinely differ rather than tying, and the order three produced them in is a mesh's free list,
+ * which `SlotContainer` keeps deliberately apart from paint order.
+ *
+ * So the tie is settled by what the user is already looking at. Hits within
+ * {@link depthSeparation} of the nearest of their run are one depth, because that is the separation
+ * below which the depth buffer stops ordering surfaces and draw order alone decides what is on top
+ * — the same rule {@link occludeHits} cuts by. Within a run they are ordered by where they draw,
+ * last first, along the three keys three's own painter sort reads in the same order: the layer
+ * group they hang under, the batch's place in that layer, then the instance's place in the batch.
+ *
+ * A run is measured from its own first hit rather than from the hit before it, so a stack of
+ * surfaces each just inside the separation is still cut into runs instead of chaining into one.
+ * @param hits - R3F's hits, nearest first.
+ * @param space - The scene's space, whose scale turns the plan-unit separation into a world one.
+ * @returns The hits in pick order.
+ */
+export function orderCoplanarHits(hits, space) {
+    if (hits.length < 2)
+        return hits;
+    const separation = depthSeparation(space.scale);
+    const ordered = [];
+    for (let start = 0; start < hits.length;) {
+        let end = start + 1;
+        while (end < hits.length) {
+            const gap = hits[end].distance - hits[start].distance;
+            // A step *back* toward the camera ends the run rather than extending it. R3F sorts by event
+            // priority first and distance second, so a second root's hits follow the first root's as their
+            // own nearest-first list — two scenes, whose hits must not be ordered against each other
+            // however near the numbers land.
+            if (gap < 0 || gap > separation)
+                break;
+            end++;
+        }
+        const run = hits.slice(start, end);
+        // Reversed, so the hit drawn last comes first. `sort` is stable, so hits nothing here orders —
+        // a primitive whose picking is not implemented, two triangles of one instance — keep the
+        // nearest-first order three gave them rather than being shuffled by a comparator with nothing
+        // to say about them.
+        if (run.length > 1)
+            run.sort((a, b) => compareDrawOrder(b, a));
+        ordered.push(...run);
+        start = end;
+    }
+    return ordered;
+}
 /**
  * Where a ray crosses the plan plane — the floor under the pointer, whatever is drawn above it.
  *
@@ -185,6 +271,61 @@ export function planePoint(ray, space) {
 function isDrag(event) {
     return event.delta * event.delta > DRAG_SLOP_SQ_PX;
 }
+/**
+ * Compares two hits by where they draw, earliest first.
+ *
+ * The three keys are three's own, read in three's order: a mesh inherits the `renderOrder` of its
+ * nearest ancestor group as its group order, which outranks its own `renderOrder`, which outranks
+ * anything within the mesh. Here that reads as the layer, then the batch, then the instance.
+ *
+ * **The layer is a key of its own because the two numberings are not one scale.** A layer's
+ * `<group>` carries its place in the whole tree's draw order, subdivided inside `[0, 2)`, while a
+ * batch mesh carries its kind's index among its layer's batches — `0`, `1`, `2`. So a batch is never
+ * comparable to a batch of another layer, and the mesh numbers alone would put the second batch of
+ * an early layer above the first batch of a late one. Collapsing them would mean giving every batch
+ * its layer's place plus a fraction, which is exactly the mantissa `Layer` keeps free for nesting.
+ *
+ * Three's own comparator is unreachable: `painterSortStable` is private to its WebGL renderer, and
+ * `renderer.renderLists` holds only the per-object answer — the instance key, the one this bug is
+ * about, exists nowhere in it.
+ *
+ * Two hits on one mesh share both object keys, and two hits on different meshes are nearly always
+ * separated by one of them, since a layer's place is unique in the tree and a batch's is unique in its
+ * layer. So the branches are exclusive in practice, which is also what keeps one mesh's places from
+ * ever being compared against another's — those count from zero independently and mean nothing
+ * against each other. Where two meshes do tie on both — the background quad draws level with the
+ * first layer, and three settles that by `material.id` — this reports nothing and the stable sort
+ * leaves them nearest-first.
+ * @param a - The first hit.
+ * @param b - The second hit.
+ * @returns Negative when `a` draws first, positive when `b` does, zero when nothing orders them.
+ */
+function compareDrawOrder(a, b) {
+    if (a.object !== b.object) {
+        return (groupOrderOf(a.object) - groupOrderOf(b.object) || a.object.renderOrder - b.object.renderOrder);
+    }
+    const source = sources.get(a.object);
+    if (!source)
+        return 0;
+    const first = source.defAt(a.instanceId);
+    const second = source.defAt(b.instanceId);
+    // A hit traced to no def reports the first place rather than the last: nothing is known about
+    // where it drew, and that must not outrank a def whose place is known.
+    return (first ? source.paintOrderOf(first) : 0) - (second ? source.paintOrderOf(second) : 0);
+}
+/**
+ * The group order three would give an object: the `renderOrder` of its nearest ancestor group,
+ * which for anything a layer holds is that layer's place in the tree's draw order.
+ * @param object - The object to place.
+ * @returns The group order, or `0` for an object under no group at all.
+ */
+function groupOrderOf(object) {
+    for (let node = object.parent; node; node = node.parent) {
+        if (node.isGroup)
+            return node.renderOrder;
+    }
+    return 0;
+}
 /**
  * Whether an object sits in an interactive layer: it, or an ancestor, carries R3F handlers.
  * @param object - The object hit.
@@ -205,7 +346,11 @@ function isInteractive(object, interaction) {
  */
 const DRAG_SLOP_SQ_PX = 15;
 /**
- * Mesh-to-def resolution for every mounted container, keyed weakly by mesh identity — so nothing has
- * to be cleaned up per renderer, and two renderers holding the same defs never collide.
+ * What speaks for each mounted container's mesh, keyed weakly by mesh identity — so nothing has to
+ * be cleaned up per renderer, and two renderers holding the same defs never collide.
+ *
+ * Kept across hot updates, because a container registers from a mount effect that a re-render does
+ * not re-run: a fresh map would leave every mesh in the scene unpickable until a full reload, which
+ * is what editing anything in this module's import graph used to do (see {@link hotState}).
  */
-const resolvers = new WeakMap();
+const sources = hotState(import.meta.hot, 'sources', () => new WeakMap());

package/dist/objects/containers/SlotContainer.d.ts

@@ -1,4 +1,4 @@
-import { type Intersection, type Object3D } from 'three';
+import { type Object3D } from 'three';
 import { type UniformSchemaShader } from '../../core/InstanceUniforms';
 import { type UniformValue } from '../../core/SquareDataTexture';
 import { type RenderableDef } from '../../types/defs';
@@ -84,10 +84,10 @@ export interface SlotContainerOptions {
  * What lives here is everything that does not depend on which def type is drawn:
  *
  * - **Slot allocation**, in both directions. `slotOf` is what a paint-order pass over the layer's
- *   defs looks each def up with, and {@link defAt} is what turns a pointer hit — which names a slot
- *   — back into the def that drew it. Slots come from a mesh's free list, so a released slot may be
- *   handed to a different def later; freeing by slot keeps both directions from outliving the claim
- *   they describe.
+ *   defs looks each def up with, and {@link defAt} is what turns a pointer hit — which names a mesh
+ *   instance — back into the def that drew it. Slots come from a mesh's free list, so a released slot
+ *   may be handed to a different def later; freeing by slot keeps both directions from outliving the
+ *   claim they describe.
  * - **Paint order**, explicitly. Instance ids come from a mesh's free list, so they do not track
  *   sibling order — a container that let slot order stand in for paint order would reorder itself
  *   after any claim/release churn, and again under StrictMode's remount, which re-claims in reverse.
@@ -188,21 +188,32 @@ export declare abstract class SlotContainer<R, M extends SlotMesh = SlotMesh, T
      */
     release(slot: number): void;
     /**
-     * The def holding a slot — the reverse of {@link claim}.
-     * @param slot - The slot to look up, or `undefined` for a hit that named none.
-     * @returns The def, or `undefined` when the slot is free.
+     * The def a mesh instance belongs to — the reverse of {@link claim}, and what picking asks, since
+     * an intersection names an instance and nothing else.
+     *
+     * The instance *is* the slot for every container but the text batch, whose defs own one member per
+     * line; that one overrides this to resolve the member's group first, which is why the parameter is
+     * the mesh's number rather than the container's.
+     * @param instance - The instance the mesh reported, or `undefined` for a hit that named none.
+     * @returns The def, or `undefined` when no claim holds that instance.
      */
-    defAt(slot: number | undefined): RenderableDef | undefined;
+    defAt(instance: number | undefined): RenderableDef | undefined;
     /**
-     * The def an intersection with this container's mesh hit.
+     * Where a def sits in this container's draw order, counted from the one drawn first.
+     *
+     * The public read of an assignment the order pass makes privately. Picking uses it to break a tie
+     * the depth buffer never resolved: two surfaces closer together than `depthSeparation` are drawn
+     * in list order rather than depth order, so list order is also what decides which of them the
+     * pointer is on (see `orderCoplanarHits`). Per def rather than per slot, because a slot is a mesh's
+     * own numbering out of a free list and a def is what the layer ordered.
      *
-     * Which field of an intersection names a slot is the container's own knowledge — `instanceId` for
-     * an instanced mesh, `batchId` for a batched one, the member id for a text batch, whose defs own
-     * several — so it is answered here rather than at each registration site.
-     * @param hit - The intersection to trace.
-     * @returns The def, or `undefined` when the hit cannot be traced to one.
+     * A def this container never ordered reports the first place rather than the last: nothing is known
+     * about where it drew, and the one thing that must not happen is for that to outrank a def whose
+     * place is known.
+     * @param def - The def to place.
+     * @returns Its place in the draw order.
      */
-    defFromHit(hit: Intersection): RenderableDef | undefined;
+    paintOrderOf(def: RenderableDef): number;
     /**
      * Registers what to do when a member turns out to belong in a sibling container; `undefined`
      * clears it.
@@ -263,6 +274,16 @@ export declare abstract class SlotContainer<R, M extends SlotMesh = SlotMesh, T
      * @param layerDimmed - Whether the layer is dimmed, inherited by defs without a `dim` of their own.
      */
     setPaintOrder(defs: readonly T[], layerDimmed: boolean): void;
+    /**
+     * The layer's defs in the order they draw, each labeled with its place in it.
+     *
+     * Every order pass starts here, the overriding ones included, so the labels exist whatever a
+     * container then does with the order — a sortable draw list for most of them, a rebuilt member
+     * list for a text batch. That is what lets {@link paintOrderOf} answer for any container's hits
+     * rather than only the ones whose mesh sorts.
+     * @returns The defs, dimmed first.
+     */
+    protected orderedDefs(): readonly T[];
     /**
      * Labels every claimed slot with its place in the layer's draw order, undimmed defs last.
      *

package/dist/objects/containers/SlotContainer.js

@@ -12,10 +12,10 @@ import { DIM_SCHEMA, DIM_UNIFORM, dimOrdered, instanceDim, isDimmed, } from '../
  * What lives here is everything that does not depend on which def type is drawn:
  *
  * - **Slot allocation**, in both directions. `slotOf` is what a paint-order pass over the layer's
- *   defs looks each def up with, and {@link defAt} is what turns a pointer hit — which names a slot
- *   — back into the def that drew it. Slots come from a mesh's free list, so a released slot may be
- *   handed to a different def later; freeing by slot keeps both directions from outliving the claim
- *   they describe.
+ *   defs looks each def up with, and {@link defAt} is what turns a pointer hit — which names a mesh
+ *   instance — back into the def that drew it. Slots come from a mesh's free list, so a released slot
+ *   may be handed to a different def later; freeing by slot keeps both directions from outliving the
+ *   claim they describe.
  * - **Paint order**, explicitly. Instance ids come from a mesh's free list, so they do not track
  *   sibling order — a container that let slot order stand in for paint order would reorder itself
  *   after any claim/release churn, and again under StrictMode's remount, which re-claims in reverse.
@@ -158,24 +158,35 @@ export class SlotContainer {
         this.defBySlot.delete(slot);
     }
     /**
-     * The def holding a slot — the reverse of {@link claim}.
-     * @param slot - The slot to look up, or `undefined` for a hit that named none.
-     * @returns The def, or `undefined` when the slot is free.
+     * The def a mesh instance belongs to — the reverse of {@link claim}, and what picking asks, since
+     * an intersection names an instance and nothing else.
+     *
+     * The instance *is* the slot for every container but the text batch, whose defs own one member per
+     * line; that one overrides this to resolve the member's group first, which is why the parameter is
+     * the mesh's number rather than the container's.
+     * @param instance - The instance the mesh reported, or `undefined` for a hit that named none.
+     * @returns The def, or `undefined` when no claim holds that instance.
      */
-    defAt(slot) {
-        return slot === undefined ? undefined : this.defBySlot.get(slot);
+    defAt(instance) {
+        return instance === undefined ? undefined : this.defBySlot.get(instance);
     }
     /**
-     * The def an intersection with this container's mesh hit.
+     * Where a def sits in this container's draw order, counted from the one drawn first.
+     *
+     * The public read of an assignment the order pass makes privately. Picking uses it to break a tie
+     * the depth buffer never resolved: two surfaces closer together than `depthSeparation` are drawn
+     * in list order rather than depth order, so list order is also what decides which of them the
+     * pointer is on (see `orderCoplanarHits`). Per def rather than per slot, because a slot is a mesh's
+     * own numbering out of a free list and a def is what the layer ordered.
      *
-     * Which field of an intersection names a slot is the container's own knowledge — `instanceId` for
-     * an instanced mesh, `batchId` for a batched one, the member id for a text batch, whose defs own
-     * several — so it is answered here rather than at each registration site.
-     * @param hit - The intersection to trace.
-     * @returns The def, or `undefined` when the hit cannot be traced to one.
+     * A def this container never ordered reports the first place rather than the last: nothing is known
+     * about where it drew, and the one thing that must not happen is for that to outrank a def whose
+     * place is known.
+     * @param def - The def to place.
+     * @returns Its place in the draw order.
      */
-    defFromHit(hit) {
-        return this.defAt(hit.instanceId);
+    paintOrderOf(def) {
+        return this.orderByDef.get(def) ?? 0;
     }
     /**
      * Registers what to do when a member turns out to belong in a sibling container; `undefined`
@@ -257,6 +268,21 @@ export class SlotContainer {
         this.layerDimmed = layerDimmed;
         this.applyOrder();
     }
+    /**
+     * The layer's defs in the order they draw, each labeled with its place in it.
+     *
+     * Every order pass starts here, the overriding ones included, so the labels exist whatever a
+     * container then does with the order — a sortable draw list for most of them, a rebuilt member
+     * list for a text batch. That is what lets {@link paintOrderOf} answer for any container's hits
+     * rather than only the ones whose mesh sorts.
+     * @returns The defs, dimmed first.
+     */
+    orderedDefs() {
+        const ordered = dimOrdered(this.layerDefs, this.layerDimmed);
+        for (let order = 0; order < ordered.length; order++)
+            this.orderByDef.set(ordered[order], order);
+        return ordered;
+    }
     /**
      * Labels every claimed slot with its place in the layer's draw order, undimmed defs last.
      *
@@ -264,10 +290,9 @@ export class SlotContainer {
      * mesh a rebuilt member list instead.
      */
     applyOrder() {
-        const ordered = dimOrdered(this.layerDefs, this.layerDimmed);
+        const ordered = this.orderedDefs();
         for (let order = 0; order < ordered.length; order++) {
             const def = ordered[order];
-            this.orderByDef.set(def, order);
             const slot = this.slotOf(def);
             if (slot === undefined)
                 continue;

package/dist/objects/containers/hooks.js

@@ -1,6 +1,6 @@
 import { useStore } from '@react-three/fiber';
 import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
-import { registerHitResolver } from '../../events/pointer';
+import { registerHitSource } from '../../events/pointer';
 import { registerSlotWriter, subscribeDef, syncNow } from '../../update';
 import { resolveDim, subscribeDim, useDimChain } from '../layer/layer-context';
 /**
@@ -52,10 +52,10 @@ export function useContainer(create, defs, onKindMismatch) {
             invalidate();
         });
     }, [container, chain, invalidate]);
-    // How a hit on this container's mesh becomes a def. From an effect, so the mesh is bound by now;
-    // the container answers which field of an intersection names its slot, so nothing here has to know
-    // one mesh kind from another.
-    useEffect(() => registerHitResolver(container.mesh, (hit) => container.defFromHit(hit)), [container]);
+    // What a hit on this container's mesh means: which def drew it, and where that def sits in the
+    // draw order. From an effect, so the mesh is bound by now; the container answers both, so nothing
+    // here has to know one mesh kind from another.
+    useEffect(() => registerHitSource(container.mesh, container), [container]);
     // Assigned after mount rather than passed to `create`, because the container is built once and
     // outlives every render, so it cannot close over a fresh callback. A caller with nothing to run on
     // a mismatch passes no handler, and this then does nothing: no call into the container and no

package/dist/objects/shapes/shape-container.d.ts

@@ -1,7 +1,7 @@
 import { type Shape } from '@expofp/geometry';
-import { type BufferGeometry, type Intersection } from 'three';
+import { type BufferGeometry } from 'three';
 import { type BatchedMeshImpl } from '../../core/batch/BatchedMesh';
-import { type RenderableDef, type ShapeDef } from '../../types/defs';
+import { type ShapeDef } from '../../types/defs';
 import { SlotContainer } from '../containers';
 /**
  * Every kind of shape batch, **in the order they draw within a layer** — which is what `Shapes`
@@ -129,13 +129,6 @@ export declare class ShapeContainer extends SlotContainer<BufferGeometry, Batche
      * @param defs - The shapes this container is about to hold.
      */
     reserve(defs: readonly ShapeDef[]): void;
-    /**
-     * A batched mesh reports the instance it hit as `batchId`, which is the slot this container
-     * allocated.
-     * @param hit - The intersection to trace.
-     * @returns The def, or `undefined` when the hit cannot be traced to one.
-     */
-    defFromHit(hit: Intersection): RenderableDef | undefined;
     protected addInstance(geometry: BufferGeometry): number;
     protected removeInstance(slot: number): void;
     /**

package/dist/objects/shapes/shape-container.js

@@ -151,15 +151,6 @@ export class ShapeContainer extends SlotContainer {
         this.target.vertices = vertices;
         this.target.indices = indices;
     }
-    /**
-     * A batched mesh reports the instance it hit as `batchId`, which is the slot this container
-     * allocated.
-     * @param hit - The intersection to trace.
-     * @returns The def, or `undefined` when the hit cannot be traced to one.
-     */
-    defFromHit(hit) {
-        return this.defAt(hit.batchId);
-    }
     addInstance(geometry) {
         const geometryId = this.geometryIdFor(geometry);
         // Full exactly when no slot is free and no room remains to append one; `addInstance` would

package/dist/objects/text/text-container.d.ts

@@ -1,4 +1,3 @@
-import { type Intersection } from 'three';
 import { type BatchedTextImpl } from '../../core/text/BatchedText';
 import { TextImpl } from '../../core/text/Text';
 import { type RenderableDef, type TextDef } from '../../types/defs';
@@ -77,11 +76,13 @@ export declare class TextContainer extends SlotContainer<number, BatchedTextImpl
      */
     setPaintOrder(defs: readonly TextDef[], layerDimmed: boolean): void;
     /**
-     * A hit names the batch member it struck, and a def owns one member per line.
-     * @param hit - The intersection to trace.
+     * The batch reports the member it was hit on, and a def owns one member per line — so unlike every
+     * other container's, this one's slots are not its mesh's instances, and a member resolves to a def
+     * only through the group holding it.
+     * @param member - The member the batch reported.
      * @returns The def, or `undefined` when no claimed group holds that member.
      */
-    defFromHit(hit: Intersection): RenderableDef | undefined;
+    defAt(member: number | undefined): RenderableDef | undefined;
     /**
      * Rebuilds the flat member order from the current defs and hands it to the batch, unless nothing
      * moved.

package/dist/objects/text/text-container.js

@@ -1,7 +1,7 @@
 import { TextImpl } from '../../core/text/Text';
 import { sameSequence } from '../../utils/arrays';
 import { SlotContainer } from '../containers';
-import { dimOrdered, isDimmed } from '../materials/effects/color-dim';
+import { isDimmed } from '../materials/effects/color-dim';
 import { LAYOUT_FONT_SIZE, LINE_HEIGHT } from './text-layout';
 /**
  * One text layer's bookkeeping: a group of members per def, and the paint order across them.
@@ -106,13 +106,14 @@ export class TextContainer extends SlotContainer {
         this.scheduleSync();
     }
     /**
-     * A hit names the batch member it struck, and a def owns one member per line.
-     * @param hit - The intersection to trace.
+     * The batch reports the member it was hit on, and a def owns one member per line — so unlike every
+     * other container's, this one's slots are not its mesh's instances, and a member resolves to a def
+     * only through the group holding it.
+     * @param member - The member the batch reported.
      * @returns The def, or `undefined` when no claimed group holds that member.
      */
-    defFromHit(hit) {
-        const member = hit.instanceId;
-        return member === undefined ? undefined : this.defAt(this.groupByMember.get(member));
+    defAt(member) {
+        return super.defAt(member === undefined ? undefined : this.groupByMember.get(member));
     }
     /**
      * Rebuilds the flat member order from the current defs and hands it to the batch, unless nothing
@@ -124,7 +125,7 @@ export class TextContainer extends SlotContainer {
      */
     applyOrder() {
         const order = [];
-        for (const def of dimOrdered(this.layerDefs, this.layerDimmed)) {
+        for (const def of this.orderedDefs()) {
             const slot = this.slotOf(def);
             if (slot === undefined)
                 continue;

package/dist/space/Scene.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useThree } from '@react-three/fiber';
 import { useEffect, useLayoutEffect, useRef, useState } from 'react';
 import { LayoutDriver } from '../events/LayoutDriver';
-import { occludeHits } from '../events/pointer';
+import { usePickFilter } from '../events/pointer';
 import { Background } from '../objects/Background';
 import { TextureBudget, TextureBudgetContext } from '../objects/images/texture-budget';
 import { Layer } from '../objects/layer/index';
@@ -84,8 +84,9 @@ function SceneGraph(props) {
     const { viewbox, staticTransform, rootLayer } = sceneDef;
     const { width, height, dpr } = useCanvasSize();
     const invalidate = useThree((state) => state.invalidate);
-    const setEvents = useThree((state) => state.setEvents);
     const space = useSpace();
+    // Here rather than on either canvas, so the renderer's own and a host's both pick alike.
+    usePickFilter();
     const [scheduler] = useState(createMountScheduler);
     // One budget for the scene's lifetime; the limit is synced rather than the budget rebuilt, so an
     // atlas's registration survives a `memoryLimit` change.
@@ -119,8 +120,6 @@ function SceneGraph(props) {
         if (!memoryLimit)
             logger.debug('no memory limit set, image atlases upload at full size');
     }, [budget, memoryLimit]);
-    // Here rather than on either mount, so the renderer's own canvas and a host's both pick through it.
-    useEffect(() => setEvents({ filter: (hits, state) => occludeHits(hits, state, space) }), [setEvents, space]);
     useEffect(() => {
         printScene(sceneDef, logger.debug);
     }, [sceneDef]);

package/dist/space/clipping.d.ts

@@ -53,20 +53,17 @@ export declare function nearPlane(distance: number, scale: number): number | und
  */
 export declare function farPlane(maxDistance: number): number;
 /**
- * Minimum z-axis separation between overlapping surfaces, in **plan** units. Picking reads it too:
- * geometry closer than this to a hit is drawn on it, so it does not occlude it (see `occludeHits`).
+ * {@link ELEVATION_PRECISION} in the world units everything downstream of the scene's space works
+ * in: the least separation at which two surfaces still draw in a defined order.
  *
- * **For plan data providers:** shapes sharing an x/y footprint — an elevated platform over a floor
- * area, layered decorations at one position — must be separated by at least this much on z to be
- * ordered correctly. No minimum horizontal separation is required: screen-pixel density and depth
- * precision both scale with camera distance and with the scene's scale, so any separation visible on
- * screen already has depth margin, at any viewport size, zoom, scale or camera rotation.
- *
- * Deliberately the renderer's own constant rather than `@expofp/geometry`'s `ELEVATION_TOLERANCE`,
- * which happens to hold the same number. They answer different questions — geometry's is "are these
- * two elevations the same point?", this one is "must these two elevations still draw in the right
- * order?" — and importing it would let a tuning of the geometry predicate silently re-tune the depth
- * buffer.
+ * Every reader of the constant needs it this way round, which is why the conversion lives here
+ * rather than at each of them. The near plane sizes the depth buffer against it, `occludeHits` keeps
+ * a hit that near behind an occluder because the occluder is drawn *on* it rather than in front of
+ * it, and `orderCoplanarHits` treats two hits that near as one depth the buffer never separated — so
+ * a tuning of the constant moves picking and drawing together, which is the only way the two can
+ * agree.
+ * @param scale - World units per plan unit, from the scene's {@link Space}.
+ * @returns The separation in world units.
  */
-export declare const ELEVATION_PRECISION = 0.1;
+export declare function depthSeparation(scale: number): number;
 //# sourceMappingURL=clipping.d.ts.map

package/dist/space/clipping.js

@@ -58,7 +58,7 @@ export function nearPlane(distance, scale) {
         return undefined;
     // Pitching the camera foreshortens an elevation along the view axis, so the separation the depth
     // buffer actually sees is the plan one times the cosine.
-    const precision = ELEVATION_PRECISION * scale * MIN_PITCH_COSINE;
+    const precision = depthSeparation(scale) * MIN_PITCH_COSINE;
     const near = (distance * distance) / (DEPTH_BUFFER_LEVELS * precision);
     return Math.min(Math.max(near, distance * (1 - HEADROOM_RATIO)), distance * (1 - MIN_HEADROOM_RATIO));
 }
@@ -72,8 +72,26 @@ export function farPlane(maxDistance) {
     return Math.max(maxDistance, 0.1) * 2;
 }
 /**
- * Minimum z-axis separation between overlapping surfaces, in **plan** units. Picking reads it too:
- * geometry closer than this to a hit is drawn on it, so it does not occlude it (see `occludeHits`).
+ * {@link ELEVATION_PRECISION} in the world units everything downstream of the scene's space works
+ * in: the least separation at which two surfaces still draw in a defined order.
+ *
+ * Every reader of the constant needs it this way round, which is why the conversion lives here
+ * rather than at each of them. The near plane sizes the depth buffer against it, `occludeHits` keeps
+ * a hit that near behind an occluder because the occluder is drawn *on* it rather than in front of
+ * it, and `orderCoplanarHits` treats two hits that near as one depth the buffer never separated — so
+ * a tuning of the constant moves picking and drawing together, which is the only way the two can
+ * agree.
+ * @param scale - World units per plan unit, from the scene's {@link Space}.
+ * @returns The separation in world units.
+ */
+export function depthSeparation(scale) {
+    return ELEVATION_PRECISION * scale;
+}
+/**
+ * Minimum z-axis separation between overlapping surfaces, in **plan** units. Picking reads it too,
+ * through {@link depthSeparation}: geometry closer than this to a hit is drawn on it rather than in
+ * front of it, so it does not occlude it, and two hits this close are one depth the buffer never
+ * ordered, so the pointer takes whichever of them draws last.
  *
  * **For plan data providers:** shapes sharing an x/y footprint — an elevated platform over a floor
  * area, layered decorations at one position — must be separated by at least this much on z to be
@@ -86,8 +104,11 @@ export function farPlane(maxDistance) {
  * two elevations the same point?", this one is "must these two elevations still draw in the right
  * order?" — and importing it would let a tuning of the geometry predicate silently re-tune the depth
  * buffer.
+ *
+ * Unexported: every reader wants it scaled, so {@link depthSeparation} is the way out of this module
+ * and this stays the one place the plan-unit figure is written down.
  */
-export const ELEVATION_PRECISION = 0.1;
+const ELEVATION_PRECISION = 0.1;
 /**
  * Fraction of the camera's distance kept clear of the near plane at close and default zoom, so
  * depth-buffer levels are not spent on the empty space between the camera and the plan.

package/dist/update/slot-writers.js

@@ -1,19 +1,6 @@
 import { isLayerDef } from '../types/guards';
+import { hotState } from '../utils/hot-state';
 import { update } from './store';
-/**
- * The write closures mounted instance components register for their defs — the single write path
- * from a def's fields into its GPU slots, and the frame that draws what they wrote.
- *
- * Two callers run them: the instance's own effect (after `update(def)`), and the camera re-layout
- * frame loop — the latter mutating defs and re-syncing them without going through React at all.
- * Sharing one closure is what keeps the two paths from disagreeing.
- *
- * A **set** per def, because one def can be drawn by more than one mesh: a model merged into a part
- * per source material has an instance in each, and an image whose source is split into tiles has one
- * per placement. Holding a single writer let the last instance to mount overwrite its siblings, so
- * every later write reached exactly one of a def's slots — a two-part model faded half of itself.
- */
-const slotWriters = new WeakMap();
 /**
  * Registers a def's sync closure, paired with the frame request that shows what it writes.
  *
@@ -70,3 +57,20 @@ export function writeChanged(defs) {
             syncNow(def);
     }
 }
+/**
+ * The write closures mounted instance components register for their defs — the single write path
+ * from a def's fields into its GPU slots, and the frame that draws what they wrote.
+ *
+ * Two callers run them: the instance's own effect (after `update(def)`), and the camera re-layout
+ * frame loop — the latter mutating defs and re-syncing them without going through React at all.
+ * Sharing one closure is what keeps the two paths from disagreeing.
+ *
+ * A **set** per def, because one def can be drawn by more than one mesh: a model merged into a part
+ * per source material has an instance in each, and an image whose source is split into tiles has one
+ * per placement. Holding a single writer let the last instance to mount overwrite its siblings, so
+ * every later write reached exactly one of a def's slots — a two-part model faded half of itself.
+ *
+ * Kept across hot updates, because an instance registers from a mount effect that a re-render does
+ * not re-run: a fresh map would make every later `update(def)` a silent no-op (see {@link hotState}).
+ */
+const slotWriters = hotState(import.meta.hot, 'slotWriters', () => new WeakMap());

package/dist/update/store.js

@@ -1,9 +1,4 @@
-/**
- * Per-def subscription state, created on first subscribe and dropped when the last subscriber
- * leaves. Keyed weakly by def identity: a def the renderer never mounted has no entry, which is
- * exactly why {@link update} on it is a no-op rather than an error.
- */
-const subscriptions = new WeakMap();
+import { hotState } from '../utils/hot-state';
 /**
  * Marks defs as changed after their fields, geometry, or `children` were mutated, so the renderer
  * mirrors the mutation into GPU state.
@@ -96,3 +91,14 @@ function notify(def) {
     for (const listener of entry.listeners)
         listener();
 }
+/**
+ * Per-def subscription state, created on first subscribe and dropped when the last subscriber
+ * leaves. Keyed weakly by def identity: a def the renderer never mounted has no entry, which is
+ * exactly why {@link update} on it is a no-op rather than an error.
+ *
+ * Kept across hot updates, because a component subscribes once and `useSyncExternalStore` re-runs
+ * that only when the subscribe function changes identity: a fresh map would leave every mounted
+ * subscriber listening to entries no `update` can reach, and that "never mounted" no-op would start
+ * swallowing real changes (see {@link hotState}).
+ */
+const subscriptions = hotState(import.meta.hot, 'subscriptions', () => new WeakMap());

package/dist/utils/hot-state.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Module-level state that survives a hot update.
+ *
+ * A registry held in a module-level `const` is lost the moment Vite re-evaluates that module, and the
+ * renderer has several that hold live wiring rather than a cache: which def a mesh's hits resolve to,
+ * which closures `update(def)` reaches, which recognizer a canvas's gestures share. Each is filled
+ * once, from a mount effect, so React Refresh — which re-renders without re-running an effect whose
+ * dependencies did not change — never refills it. The module comes back empty, every lookup through
+ * it misses, and the feature goes quiet with no error anywhere: picking stops resolving defs, updates
+ * stop reaching slots.
+ */
+/** The part of Vite's `import.meta.hot` this needs, taken structurally so nothing imports its type. */
+interface HotModule {
+    /**
+     * Carried over to the next instance of the same module by every hot update.
+     *
+     * Optional because a host may offer a hot context without one: vitest defines `import.meta.hot` for
+     * its own watch-mode reload and leaves `data` unset, so reading through it throws at import time
+     * and takes the importing module down with it.
+     */
+    data?: Record<string, unknown>;
+}
+/**
+ * The value a module keeps across its own hot updates, built on first use.
+ *
+ * Each module passes its own `import.meta.hot`, which is `undefined` in a production build — Vite
+ * replaces the expression statically, so the branch and this whole module fall away and the call is
+ * nothing but the builder. That is also what makes this safe to reach for: it changes development
+ * only, and the value a module gets is the same value either way.
+ * @param hot - The calling module's `import.meta.hot`.
+ * @param key - Names the value within the module, so one module may keep several.
+ * @param build - Builds the value the first time the module is evaluated.
+ * @returns The value, built now or carried over from the instance before.
+ * @example
+ * ```ts
+ * const sources = hotState(import.meta.hot, 'sources', () => new WeakMap<Object3D, HitSource>());
+ * ```
+ */
+export declare function hotState<T>(hot: HotModule | undefined, key: string, build: () => T): T;
+export {};
+//# sourceMappingURL=hot-state.d.ts.map

package/dist/utils/hot-state.js

@@ -0,0 +1,37 @@
+/**
+ * Module-level state that survives a hot update.
+ *
+ * A registry held in a module-level `const` is lost the moment Vite re-evaluates that module, and the
+ * renderer has several that hold live wiring rather than a cache: which def a mesh's hits resolve to,
+ * which closures `update(def)` reaches, which recognizer a canvas's gestures share. Each is filled
+ * once, from a mount effect, so React Refresh — which re-renders without re-running an effect whose
+ * dependencies did not change — never refills it. The module comes back empty, every lookup through
+ * it misses, and the feature goes quiet with no error anywhere: picking stops resolving defs, updates
+ * stop reaching slots.
+ */
+/**
+ * The value a module keeps across its own hot updates, built on first use.
+ *
+ * Each module passes its own `import.meta.hot`, which is `undefined` in a production build — Vite
+ * replaces the expression statically, so the branch and this whole module fall away and the call is
+ * nothing but the builder. That is also what makes this safe to reach for: it changes development
+ * only, and the value a module gets is the same value either way.
+ * @param hot - The calling module's `import.meta.hot`.
+ * @param key - Names the value within the module, so one module may keep several.
+ * @param build - Builds the value the first time the module is evaluated.
+ * @returns The value, built now or carried over from the instance before.
+ * @example
+ * ```ts
+ * const sources = hotState(import.meta.hot, 'sources', () => new WeakMap<Object3D, HitSource>());
+ * ```
+ */
+export function hotState(hot, key, build) {
+    const data = hot?.data;
+    if (!data)
+        return build();
+    // `in` rather than a comparison against undefined, so a value that is legitimately undefined is
+    // kept rather than rebuilt on every update.
+    if (!(key in data))
+        data[key] = build();
+    return data[key];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/renderer",
-  "version": "3.44.0",
+  "version": "3.44.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/expofp/efp-app.git",
@@ -42,7 +42,7 @@
     "troika-three-text": "^0.52.5",
     "tslib": "^2.3.0",
     "webgl-memory": "^1.1.3",
-    "@expofp/geometry": "3.44.0"
+    "@expofp/geometry": "3.44.1"
   },
   "devDependencies": {
     "@react-three/test-renderer": "^9.1.0",