@weasel-js/kernel3d 1.18.1 → 1.19.0

package/dist/index.d.ts

@@ -53,14 +53,16 @@ declare const DEFAULT_ORBIT_LIMITS: OrbitLimits;
  *  itself when it already holds. */
 declare function clampCamera(camera: Camera3d, limits?: Partial<OrbitLimits>): Camera3d;
 /** The camera turned about its target by the given radians, pitch held inside
- *  `limits`. Yaw is not wrapped. */
+ *  `limits`. Yaw is not wrapped. A turn that is not finite leaves it as it is. */
 declare function orbitBy(camera: Camera3d, deltaYaw: number, deltaPitch: number, limits?: Partial<OrbitLimits>): Camera3d;
-/** The camera with its distance multiplied by `factor`, held inside `limits`. */
+/** The camera with its distance multiplied by `factor`, held inside `limits`.
+ *  A `NaN` factor leaves it as it is. */
 declare function dollyBy(camera: Camera3d, factor: number, limits?: Partial<OrbitLimits>): Camera3d;
 /**
  * The camera with its target slid across the screen plane, so the point at the
  * target follows a pointer that moved `dx`, `dy` CSS pixels in a pane
- * `paneHeight` pixels tall. Neither angle nor distance changes.
+ * `paneHeight` pixels tall. Neither angle nor distance changes. A pan that
+ * carries the target past the double range leaves the camera as it is.
  */
 declare function panBy(camera: Camera3d, dx: number, dy: number, paneHeight: number): Camera3d;
 /**
@@ -209,14 +211,18 @@ interface Viewport3d {
     originX?: number;
     originY?: number;
 }
-/** Read on every dep call, so a dep always sees the current camera and pane. */
-type ViewportSource = () => Viewport3d;
+/**
+ * The viewport the view `viewId` looks through, read on every dep call so a
+ * dep always sees the current camera and pane. `viewId` is a `<CanvasView>`'s
+ * id; absent or `null`, the surface's own camera.
+ */
+type ViewportSource = (viewId?: string | null) => Viewport3d;
 type Point$1 = {
     x: number;
     y: number;
 };
-/** Where `p` draws in the viewport, or null when it is behind the near plane
- *  or projects to nothing finite. */
+/** Where `p` draws in the viewport, or null when it is behind the near plane,
+ *  the pane has no area, or it projects to nothing finite. */
 declare function projectPoint(p: Vec3, viewport: Viewport3d): Point$1 | null;
 
 /** The 3D world every dep is built from: core's scene with a `Pose3`, the
@@ -273,7 +279,8 @@ declare function screenBoxOf<TData, TLayer extends string>(world: World3d<TData,
 /**
  * The kit's deps, implemented against a 3D world.
  *
- * Every one of these takes its camera from a thunk rather than an argument:
+ * Every one of these takes its camera from a thunk rather than an argument,
+ * `world.viewport(viewId)` for the view it was built for:
  * the dispatcher keeps handing actions two numbers, and what makes them mean
  * something in 3D is the camera each dep already closes over.
  */
@@ -283,14 +290,27 @@ declare function screenBoxOf<TData, TLayer extends string>(world: World3d<TData,
  *
  * The kit calls this with what it believes is a world point; a 3D host feeds
  * the dispatcher an identity `clientToWorld`, so it is the pane-relative screen
- * point, which is exactly what a ray needs.
+ * point, which is exactly what a ray needs. *
+ * `viewId` names the view whose camera casts the ray; a surface with several
+ * 3D views gives each `<CanvasView deps>` its own. The same goes for every
+ * factory here that takes one.
+ */
+declare function createNodeAtPoint<TData, TLayer extends string>(world: World3d<TData, TLayer>, viewId?: string | null): NodeAtPointDep;
+/**
+ * `<SceneCanvas geometry={{ pickEvery }}>` over a 3D world: the node along the
+ * ray the point names, cast from the camera of the view the pick is asked for.
  */
-declare function createNodeAtPoint<TData, TLayer extends string>(world: World3d<TData, TLayer>): NodeAtPointDep;
+declare function createPickEvery<TData, TLayer extends string>(world: World3d<TData, TLayer>): (point: {
+    x: number;
+    y: number;
+}, view?: {
+    viewId?: string | null;
+}) => NodeId | null;
 /** Marquee: the nodes whose projected box the screen rectangle touches, in render order. */
 declare function createAreaSelect<TData, TLayer extends string>(world: World3d<TData, TLayer>, selection: {
     get(): readonly NodeId[];
     set(ids: NodeId[]): void;
-}): AreaSelectDep;
+}, viewId?: string | null): AreaSelectDep;
 /** Options for `createSnap`. */
 interface Snap3dOptions {
     /** What a gesture snaps to, in order: earlier wins a full tie. Two sharing
@@ -305,6 +325,8 @@ interface Snap3dOptions {
     /** Where the marks of the snap in flight are written, for a host to draw
      *  with `projectSnapMarks`. */
     store?: SnapOutcomeStore<Vec3>;
+    /** The view whose camera a gesture is cast through. Default the surface's. */
+    viewId?: string | null;
 }
 /**
  * The `snap` dep over a 3D world. A gesture's `omit` is honored; its 2D
@@ -327,7 +349,7 @@ declare function createSnap<TData, TLayer extends string>(world: World3d<TData,
  * through the pose they were handed, facing the camera, so nothing they
  * produce changes depth.
  */
-declare function createPoseDescriptor<TData, TLayer extends string>(world: World3d<TData, TLayer>): PoseDescriptor<Pose3, Node3d<TData, TLayer>>;
+declare function createPoseDescriptor<TData, TLayer extends string>(world: World3d<TData, TLayer>, viewId?: string | null): PoseDescriptor<Pose3, Node3d<TData, TLayer>>;
 
 /** The `insert` dep over a 3D world: a drag becomes a footprint on the ground. */
 
@@ -348,6 +370,8 @@ interface Footprint {
  */
 declare function createInsert(opts: {
     viewport: ViewportSource;
+    /** The view whose camera a drag is cast through, for a `<CanvasView deps>` of its own. Default the surface's. */
+    viewId?: string | null;
     up?: Vec3;
     /** Smallest footprint a click-sized drag produces. Default 0.25. */
     minExtent?: number;
@@ -419,8 +443,9 @@ interface GroundGridSourceOptions {
 /**
  * A grid on the ground plane as snap targets: for each pointer or geometry
  * probe on the ground, the grid line on either side of it along each of the
- * ground's two axes. Its reach is unlimited and it is a fallback, so it
- * holds every axis no target claims and never displaces one.
+ * ground's two axes, none along an axis where the probe lies so far out that
+ * lines a step apart are no longer two numbers. Its reach is unlimited and it
+ * is a fallback, so it holds every axis no target claims and never displaces one.
  */
 declare function groundGridSource(opts: GroundGridSourceOptions): SnapSource<Vec3>;
 
@@ -709,5 +734,5 @@ declare const kernel3dKitSettingsSchema: Omit<_weasel_js_prefs.PrefGroup, "child
     };
 };
 
-export { DEFAULT_ORBIT_LIMITS, HEAD, HEAD_OVERDRAW, LINE_FLOATS, MAX_PITCH, POSE3_COMPOSITION, UNIT_CUBE, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, cameraView, cameraViewProjection, clampCamera, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createLinePass, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, dollyToward, groundGridSource, headFor, homeAction, kernel3dKitSettingsSchema, layoutLine, ndcToScreen, orbitAction, orbitBy, packLines, panAction, panBy, pinchDollyAction, pose3, poseMatrix, projectAabbToScreen, projectPoint, projectSnapMarks, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool, visibleRuns, worldPoseOf };
+export { DEFAULT_ORBIT_LIMITS, HEAD, HEAD_OVERDRAW, LINE_FLOATS, MAX_PITCH, POSE3_COMPOSITION, UNIT_CUBE, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, cameraView, cameraViewProjection, clampCamera, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createLinePass, createNodeAtPoint, createPickEvery, createPoseDescriptor, createSnap, dollyAction, dollyBy, dollyToward, groundGridSource, headFor, homeAction, kernel3dKitSettingsSchema, layoutLine, ndcToScreen, orbitAction, orbitBy, packLines, panAction, panBy, pinchDollyAction, pose3, poseMatrix, projectAabbToScreen, projectPoint, projectSnapMarks, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool, visibleRuns, worldPoseOf };
 export type { Aim3d, Aim3dOptions, Camera3d, Camera3dDep, ChromeBox, Footprint, Frustum3d, GroundGridSourceOptions, HeadShape, HeadSize, Line3, LineDrawOptions, LineLayout, LinePass, LineRun3, Node3d, NodeBounds, Orbit3dKitSettings, OrbitLimits, Pose3, Scene3d, ScreenBox, ScreenLine, ScreenPoint, Snap3dOptions, Viewport3d, ViewportSource, VisibleRun3, World3d };

package/dist/index.js

@@ -1,6 +1,6 @@
-import { lookAt, multiply, perspective, add, scale, quatIdentity, compose, transformAabb, quatMultiply, quatConjugate, quatRotate, sub, invert, transformPoint, normalize, transformPoint4, distance, dot, len, aabbOfPoints, intersectRayPlane, pointOnRay, cross, intersectRayAabb } from '@weasel-js/geom/3d';
+import { lookAt, multiply, perspective, add, scale, quatIdentity, compose, transformAabb, quatMultiply, quatConjugate, quatRotate, sub, invert, transformPoint, normalize, cross, dot, transformPoint4, distance, len, aabbOfPoints, intersectRayPlane, pointOnRay, intersectRayAabb } from '@weasel-js/geom/3d';
 import { clamp, lengthTable, curveSpan, rectsOverlap } from '@weasel-js/geom';
-import { scenePoseFrame, createSnapOutcomeStore, assertSnapSourceIds, DEFAULT_SNAP_PX, resolveOverlays, snapSourcesFor, resolvedSnapMarks, SNAP_AXIS_STEP, gatherSnapCandidates, scenePoseAdapter, composeWorldPose } from '@weasel-js/core/engine';
+import { scenePoseFrame, createSnapOutcomeStore, assertSnapSourceIds, DEFAULT_SNAP_PX, resolveOverlays, snapSourcesFor, resolveHolding, resolvedSnapMarks, SNAP_AXIS_STEP, gatherSnapCandidates, scenePoseAdapter, composeWorldPose } from '@weasel-js/core/engine';
 import { isDev } from '@weasel-js/react';
 import { closestOnFlat, resolveSnap, createBvh, stepLine, createSettledCache } from '@weasel-js/geom/nd';
 import { overlaysOf, defineTool } from '@weasel-js/routing';
@@ -45,19 +45,23 @@ var DEFAULT_ORBIT_LIMITS = {
 };
 function clampCamera(camera, limits = {}) {
   const l = { ...DEFAULT_ORBIT_LIMITS, ...limits };
-  const pitch = clamp(camera.pitch, Math.max(-MAX_PITCH, l.minPitch), Math.min(MAX_PITCH, l.maxPitch));
+  const pitch = clamp(camera.pitch, clamp(l.minPitch, -MAX_PITCH, MAX_PITCH), clamp(l.maxPitch, -MAX_PITCH, MAX_PITCH));
   const distance2 = clamp(camera.distance, l.minDistance, l.maxDistance);
   if (pitch === camera.pitch && distance2 === camera.distance) return camera;
   return { ...camera, pitch, distance: distance2 };
 }
+function heldFinite(camera, moved) {
+  const { target: t, yaw, pitch, distance: distance2 } = moved;
+  return Number.isFinite(t.x + t.y + t.z + yaw + pitch + distance2) ? moved : camera;
+}
 function orbitBy(camera, deltaYaw, deltaPitch, limits) {
-  return clampCamera(
+  return heldFinite(camera, clampCamera(
     { ...camera, yaw: camera.yaw + deltaYaw, pitch: camera.pitch + deltaPitch },
     limits
-  );
+  ));
 }
 function dollyBy(camera, factor, limits) {
-  return clampCamera({ ...camera, distance: camera.distance * factor }, limits);
+  return heldFinite(camera, clampCamera({ ...camera, distance: camera.distance * factor }, limits));
 }
 function panBy(camera, dx, dy, paneHeight) {
   if (!(paneHeight > 0)) return camera;
@@ -70,7 +74,7 @@ function panBy(camera, dx, dy, paneHeight) {
     z: -Math.cos(yaw) * Math.sin(pitch)
   };
   const shift = add(scale(right, -dx * perPixel), scale(up, dy * perPixel));
-  return { ...camera, target: add(camera.target, shift) };
+  return heldFinite(camera, { ...camera, target: add(camera.target, shift) });
 }
 function dollyToward(camera, factor, at, pane, limits) {
   const dollied = dollyBy(camera, factor, limits);
@@ -81,14 +85,14 @@ function dollyToward(camera, factor, at, pane, limits) {
     -kept * (at.y - pane.height / 2),
     pane.height
   );
-  return { ...dollied, target: moved.target };
+  return heldFinite(camera, { ...dollied, target: moved.target });
 }
 var UNIT_CUBE = {
   min: { x: -0.5, y: -0.5, z: -0.5 },
   max: { x: 0.5, y: 0.5, z: 0.5 }
 };
-function pose3(position, scale6 = { x: 1, y: 1, z: 1 }, rotation = quatIdentity()) {
-  return { position, rotation, scale: scale6 };
+function pose3(position, scale7 = { x: 1, y: 1, z: 1 }, rotation = quatIdentity()) {
+  return { position, rotation, scale: scale7 };
 }
 function poseMatrix(pose) {
   return compose(pose.position, pose.rotation, pose.scale);
@@ -97,10 +101,14 @@ function aabbOfPose(pose, local = UNIT_CUBE) {
   return transformAabb(poseMatrix(pose), local);
 }
 var times = (a, b) => ({ x: a.x * b.x, y: a.y * b.y, z: a.z * b.z });
+var overAxis = (a, s, zero) => {
+  const q = a / s;
+  return s === 0 || !Number.isFinite(q) ? zero : q;
+};
 var over = (a, s, zero) => ({
-  x: s.x === 0 ? zero.x : a.x / s.x,
-  y: s.y === 0 ? zero.y : a.y / s.y,
-  z: s.z === 0 ? zero.z : a.z / s.z
+  x: overAxis(a.x, s.x, zero.x),
+  y: overAxis(a.y, s.y, zero.y),
+  z: overAxis(a.z, s.z, zero.z)
 });
 var ORIGIN = { x: 0, y: 0, z: 0 };
 var POSE3_COMPOSITION = {
@@ -129,7 +137,8 @@ function ndcToScreen(ndc, rect) {
   };
 }
 function rayThroughScreenPoint(point, rect, viewProjection) {
-  const inv = invert(viewProjection);
+  const eye = eyeOf(viewProjection) ?? ORIGIN2;
+  const inv = invert(multiply(viewProjection, compose(eye, quatIdentity(), UNIT)));
   if (!inv) return null;
   const ndc = screenToNdc(point, rect);
   const near = transformPoint(inv, { x: ndc.x, y: ndc.y, z: -1 });
@@ -137,7 +146,19 @@ function rayThroughScreenPoint(point, rect, viewProjection) {
   const direction = sub(far, near);
   const unit = normalize(direction);
   if (unit.x === 0 && unit.y === 0 && unit.z === 0) return null;
-  return { origin: near, direction };
+  return { origin: add(eye, near), direction };
+}
+var ORIGIN2 = { x: 0, y: 0, z: 0 };
+var UNIT = { x: 1, y: 1, z: 1 };
+function eyeOf(m) {
+  const row = (r) => ({ x: m[r], y: m[4 + r], z: m[8 + r] });
+  const [a, b, c] = [row(0), row(1), row(3)];
+  const bc = cross(b, c);
+  const ca = cross(c, a);
+  const ab = cross(a, b);
+  const det = dot(a, bc);
+  const eye = scale(add(add(scale(bc, m[12]), scale(ca, m[13])), scale(ab, m[15])), -1 / det);
+  return Number.isFinite(eye.x + eye.y + eye.z) ? eye : null;
 }
 var CLIP_SIDES = [
   (p) => p[2] + p[3],
@@ -153,6 +174,7 @@ function lerpClip(a, b, t) {
 }
 var EDGE_BITS = [1, 2, 4];
 function projectAabbToScreen(box, viewProjection, rect) {
+  if (!(rect.width > 0 && rect.height > 0)) return null;
   const corners = [];
   for (let i = 0; i < 8; i++) {
     const corner = {
@@ -186,7 +208,7 @@ function projectAabbToScreen(box, viewProjection, rect) {
       for (const side of CLIP_SIDES) {
         const da = side(a);
         const db = side(b);
-        if (da < 0 && db < 0) {
+        if (Number.isNaN(da) || Number.isNaN(db) || da < 0 && db < 0) {
           t0 = 1;
           t1 = 0;
           break;
@@ -200,7 +222,8 @@ function projectAabbToScreen(box, viewProjection, rect) {
     }
   }
   if (!any) return null;
-  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+  const out = { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+  return Number.isFinite(out.x + out.y + out.width + out.height) ? out : null;
 }
 function rectOf(viewport) {
   return {
@@ -217,8 +240,9 @@ function rayAt(viewport, point) {
   return rayThroughScreenPoint(point, rectOf(viewport), viewProjectionOf(viewport));
 }
 function projectPoint(p, viewport) {
+  if (!(viewport.width > 0 && viewport.height > 0)) return null;
   const [x, y, z, w] = transformPoint4(viewProjectionOf(viewport), p);
-  if (!(w > 0) || z < -w) return null;
+  if (!(w > 0) || !(z >= -w)) return null;
   const screen = ndcToScreen({ x: x / w, y: y / w }, rectOf(viewport));
   return Number.isFinite(screen.x) && Number.isFinite(screen.y) ? screen : null;
 }
@@ -257,8 +281,8 @@ function worldPoses(scene, reading) {
     return (id) => frame.world(id);
   }
   const adapter = scenePoseAdapter(untyped);
-  const compose2 = scene.composition.compose;
-  return (id) => composeWorldPose(adapter, id, compose2);
+  const compose3 = scene.composition.compose;
+  return (id) => composeWorldPose(adapter, id, compose3);
 }
 function boxAt(world, node, pose) {
   if (world.bounds) return world.bounds(pose === node.pose ? node : { ...node, pose });
@@ -517,7 +541,7 @@ function createSession3d(inputs) {
   return {
     at(p, mods) {
       if (!frame) return unsnapped(p);
-      const vp = world.viewport();
+      const vp = world.viewport(inputs.viewId);
       const screen = frame.anchor(vp);
       const anchor = screen && castOnto(vp, screen, up, frame.offset);
       const hit = screen && castOnto(vp, { x: screen.x + p.x - req.press.x, y: screen.y + p.y - req.press.y }, up, frame.offset);
@@ -532,16 +556,17 @@ function createSession3d(inputs) {
         store.set([]);
       } else {
         const probes = frame.probes(anchor);
-        const res = resolveSnap({
-          probes: probes.map((q) => ({ id: q.id, at: tuple(q.at), role: q.role })),
+        const at = probes.map((q) => ({ id: q.id, at: tuple(q.at), role: q.role }));
+        const res = resolveHolding(candidatesOf(inputs, sources, probes, delta0, vp, origin, up), (kept) => resolveSnap({
+          probes: at,
           input,
           delta0: tuple(delta0),
-          candidates: candidatesOf(inputs, sources, probes, delta0, vp, origin, up),
+          candidates: kept,
           toScreen: (w) => {
             const s = projectPoint(vec3Of(w), vp);
             return s ? [s.x, s.y] : [NaN, NaN];
           }
-        });
+        }), vec3Of);
         delta = vec3Of(res.delta);
         held = res.members.length > 0;
         store.set(resolvedSnapMarks(res.satisfied, delta));
@@ -632,16 +657,20 @@ function movedOnLevel(pose, delta, upAxis) {
   const position = { ...add(pose.position, delta), [upAxis]: pose.position[upAxis] };
   return { ...pose, position };
 }
-function createNodeAtPoint(world) {
-  return (point, exclude) => {
-    const ray = rayAt(world.viewport(), point);
-    if (!ray) return null;
-    return worldPickIndex(world).nearestOnRay(ray, exclude ? new Set(exclude) : null, 1);
-  };
+function createNodeAtPoint(world, viewId) {
+  return (point, exclude) => pickOnRay(world, viewId, point, exclude);
+}
+function pickOnRay(world, viewId, point, exclude) {
+  const ray = rayAt(world.viewport(viewId), point);
+  if (!ray) return null;
+  return worldPickIndex(world).nearestOnRay(ray, exclude ? new Set(exclude) : null, 1);
+}
+function createPickEvery(world) {
+  return (point, view) => pickOnRay(world, view?.viewId, point);
 }
-function createAreaSelect(world, selection) {
+function createAreaSelect(world, selection, viewId) {
   return {
-    hitTestArea: (bounds) => worldPickIndex(world).inScreenRect(world.viewport(), bounds),
+    hitTestArea: (bounds) => worldPickIndex(world).inScreenRect(world.viewport(viewId), bounds),
     getSelection: () => [...selection.get()],
     setSelection: (ids) => selection.set([...ids])
   };
@@ -668,25 +697,26 @@ function createSnap(world, opts = {}) {
         world,
         sources,
         store,
+        viewId: opts.viewId,
         reachPx: opts.reachPx ?? opts.kitSettings?.get("targets.snapPx") ?? DEFAULT_SNAP_PX
       });
     }
   };
 }
-function createPoseDescriptor(world) {
+function createPoseDescriptor(world, viewId) {
   const up = world.up ?? DEFAULT_UP;
   const upAxis = groundAxes(up).up;
   const specialized = /* @__PURE__ */ new WeakMap();
   let lastCastable = null;
   function castableViewport() {
-    const vp = world.viewport();
+    const vp = world.viewport(viewId);
     const rect = rectOf(vp);
     if (rayAt(vp, { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 })) lastCastable = vp;
     return lastCastable;
   }
   function build3(worldBox) {
     const boundsIn = (vp, pose) => projectAabbToScreen(worldBox(pose), viewProjectionOf(vp), rectOf(vp));
-    const boundsOf = (pose) => boundsIn(world.viewport(), pose);
+    const boundsOf = (pose) => boundsIn(world.viewport(viewId), pose);
     const descriptor = {
       forNode(node) {
         let d = specialized.get(node);
@@ -719,8 +749,8 @@ function createPoseDescriptor(world) {
         const ky = src.height === 0 ? 1 : dst.height / src.height;
         const from = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
         const to = {
-          x: dst.x + (from.x - src.x) * kx,
-          y: dst.y + (from.y - src.y) * ky
+          x: from.x + (dst.x - src.x) + (from.x - src.x) * (kx - 1),
+          y: from.y + (dst.y - src.y) + (from.y - src.y) * (ky - 1)
         };
         const plane = viewPlaneAt(vp.camera, pose.position);
         const before = onPlane(vp, plane, from);
@@ -824,7 +854,7 @@ function createInsert(opts) {
   const { u, v } = groundAxes(up);
   return {
     commit(bounds, extras, ends, select) {
-      const vp = opts.viewport();
+      const vp = opts.viewport(opts.viewId);
       const hits = footprintPoints(bounds, ends, (p) => groundHit(vp, p, up));
       if (hits.length === 0) return null;
       let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
@@ -940,7 +970,7 @@ function aimSpace3d(viewport, viewId, opts = {}) {
     },
     unproject(px) {
       const hit = groundHit(viewport, { x: px.x + ox, y: px.y + oy }, up);
-      return hit && toAimPoint(hit, axes);
+      return hit && { ...toAimPoint(hit, axes), z: 0 };
     }
   };
 }
@@ -949,8 +979,8 @@ function cameraOfAim3d(aim) {
 }
 var AXES = ["x", "y", "z"];
 var BITS = [1, 2, 4];
-var UNIT = { x: { x: 1, y: 0, z: 0 }, y: { x: 0, y: 1, z: 0 }, z: { x: 0, y: 0, z: 1 } };
-var ACROSS = { x: [UNIT.y, UNIT.z], y: [UNIT.x, UNIT.z], z: [UNIT.x, UNIT.y] };
+var UNIT2 = { x: { x: 1, y: 0, z: 0 }, y: { x: 0, y: 1, z: 0 }, z: { x: 0, y: 0, z: 1 } };
+var ACROSS = { x: [UNIT2.y, UNIT2.z], y: [UNIT2.x, UNIT2.z], z: [UNIT2.x, UNIT2.y] };
 function boxesNear(world, q, r) {
   return snapBoxes(world, q.exclude, q.probes.map(({ at: p }) => padQuery([p.x - r, p.y - r, p.z - r, p.x + r, p.y + r, p.z + r])));
 }
@@ -1067,7 +1097,9 @@ function groundGridSource(opts) {
   const up = normalize(opts.up ?? DEFAULT_UP);
   const [u, v] = planeBasis(up);
   const lines = (c) => {
-    const near = Math.round(c / opts.step) * opts.step;
+    const k = Math.round(c / opts.step);
+    if (!Number.isSafeInteger(k)) return [];
+    const near = k * opts.step;
     return [near, near + (c >= near ? opts.step : -opts.step)];
   };
   return {
@@ -1134,9 +1166,10 @@ var HEAD = { lenRatio: 8, maxShare: 0.5, aspect: 7 / 16 };
 var HEAD_OVERDRAW = 0.1;
 function headFor(shaftHalf, linePx = Number.POSITIVE_INFINITY, head = HEAD) {
   const wanted = shaftHalf * head.lenRatio;
-  const headLen = Math.max(0, Math.min(wanted, head.maxShare * linePx));
+  const cap = head.maxShare === 0 ? 0 : head.maxShare * linePx;
+  const headLen = Math.max(0, Math.min(wanted, cap));
   const headHalf = headLen * head.aspect;
-  const shrunk = wanted > 0 ? shaftHalf * headLen / wanted : shaftHalf;
+  const shrunk = wanted > 0 ? shaftHalf * (headLen / wanted) : shaftHalf;
   return { headLen, headHalf, shaftHalf: wanted > 0 ? Math.min(shrunk, headHalf) : shrunk };
 }
 function layoutLine(shaftHalf, length, pxPerUnit, head) {
@@ -1314,7 +1347,7 @@ void main() {
   if (wanted > 0.0 && density > 0.0) {
     headPx = max(0.0, min(wanted, a_shape.z * density * total));
     headHalf = headPx * a_shape.w;
-    shaft = min(shaftHalf * headPx / wanted, headHalf);
+    shaft = min(shaftHalf * (headPx / wanted), headHalf);
     shaftEnd = total - headPx / density * (1.0 - OVERDRAW);
   }
 
@@ -1474,10 +1507,11 @@ function cameraStepper(dep, zero, relative, step) {
   let reached = zero;
   let written = origin;
   let prior = origin;
+  let caughtUp = false;
   return (at) => {
     if (!dep || !origin) return;
     const now = dep.get();
-    if (now !== written && now !== prior) {
+    if (now !== written && (caughtUp || now !== prior)) {
       origin = now;
       from = reached;
     }
@@ -1485,9 +1519,11 @@ function cameraStepper(dep, zero, relative, step) {
     written = step(origin, relative(at, from), dep);
     reached = at;
     dep.set(written);
+    caughtUp = dep.get() === written;
   };
 }
 function dragCamera(ctx, kind, step) {
+  if (!ctx.deps.camera3d) return {};
   const apply = cameraStepper(ctx.deps.camera3d, { x: 0, y: 0 }, (a, b) => ({ x: a.x - b.x, y: a.y - b.y }), step);
   return {
     kind,
@@ -1550,13 +1586,14 @@ var dollyAction = {
     timing: "immediate",
     run(deps, params) {
       const dep = deps.camera3d;
-      if (!dep) return;
+      if (!dep) return "pass";
       const factor = typeof params?.scale === "number" ? 1 / params.scale : Math.exp(
         (typeof params?.deltaY === "number" ? params.deltaY : 0) * (deps.kitSettings?.get("orbit3d.dollyRate") ?? DOLLY_RATE)
       );
-      if (!(factor > 0) || !Number.isFinite(factor)) return;
+      if (!(factor > 0) || !Number.isFinite(factor) || factor === 1) return "pass";
       const pane = dep.size();
       dep.set(dollyToward(dep.get(), factor, paneAnchor(wheelPoint(params), dep, pane), pane, dep.limits?.()));
+      return void 0;
     }
   }
 };
@@ -1570,6 +1607,7 @@ var pinchDollyAction = {
     timing: "ongoing",
     start(ctx) {
       const dep = ctx.deps.camera3d;
+      if (!dep) return {};
       const startSpread = ctx.multiTouch?.spread ?? 0;
       const at = ctx.multiTouch?.centroid;
       const apply = cameraStepper(dep, 1, (a, b) => a / b, (origin, factor, d) => {
@@ -1598,7 +1636,9 @@ var homeAction = {
     run(deps) {
       const dep = deps.camera3d;
       const home = dep?.home?.();
-      if (dep && home) dep.set(home);
+      if (!dep || !home) return "pass";
+      dep.set(home);
+      return void 0;
     }
   }
 };
@@ -1621,6 +1661,6 @@ var kernel3dKitSettingsSchema = pref.group("3D camera", {
   })
 });
 
-export { DEFAULT_ORBIT_LIMITS, HEAD, HEAD_OVERDRAW, LINE_FLOATS, MAX_PITCH, POSE3_COMPOSITION, UNIT_CUBE, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, cameraView, cameraViewProjection, clampCamera, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createLinePass, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, dollyToward, groundGridSource, headFor, homeAction, kernel3dKitSettingsSchema, layoutLine, ndcToScreen, orbitAction, orbitBy, packLines, panAction, panBy, pinchDollyAction, pose3, poseMatrix, projectAabbToScreen, projectPoint, projectSnapMarks, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool, visibleRuns, worldPoseOf };
+export { DEFAULT_ORBIT_LIMITS, HEAD, HEAD_OVERDRAW, LINE_FLOATS, MAX_PITCH, POSE3_COMPOSITION, UNIT_CUBE, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, cameraView, cameraViewProjection, clampCamera, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createLinePass, createNodeAtPoint, createPickEvery, createPoseDescriptor, createSnap, dollyAction, dollyBy, dollyToward, groundGridSource, headFor, homeAction, kernel3dKitSettingsSchema, layoutLine, ndcToScreen, orbitAction, orbitBy, packLines, panAction, panBy, pinchDollyAction, pose3, poseMatrix, projectAabbToScreen, projectPoint, projectSnapMarks, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool, visibleRuns, worldPoseOf };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map