@weasel-js/kernel3d 1.4.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 orochi235
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# @weasel-js/kernel3d
+
+Poses, an orbit camera, ray picking and screen-projected chrome geometry for
+weasel, over `@weasel-js/core`'s scene graph and dispatcher.
+
+**It hosts a renderer rather than owning one.** A consumer brings its own — a
+bespoke WebGL pass, three.js, anything — and the kernel hands it poses. Nothing
+here touches WebGL.
+
+```ts
+import { createScene } from '@weasel-js/core';
+import {
+  createCamera, createNodeAtPoint, createPoseDescriptor, pose3, type Pose3,
+} from '@weasel-js/kernel3d';
+
+const scene = createScene<MyData, 'solids', Pose3>({ systemLayers: [{ id: 'solids' }] });
+const world = { scene, viewport: () => ({ camera, width, height }) };
+
+// Every dep takes its camera from a thunk. That is the whole trick: the
+// dispatcher keeps handing actions two numbers, and the camera each dep closes
+// over is what makes them a ray.
+const nodeAtPoint = createNodeAtPoint(world);
+const poseDescriptor = createPoseDescriptor(world);
+```
+
+## What core did not have to change
+
+`Scene` is generic over its pose and holds a `Pose3` — position, quaternion,
+scale — with no adapter and no special case. `InvocationCtx` still carries two
+numbers: a 3D host passes the dispatcher an identity `clientToWorld`, so
+`ctx.world` is the screen point, and each dep rebuilds the ray itself. Tools,
+the select tool included, transfer untouched.
+
+Two things do not, and the kernel says so rather than guessing:
+
+- **`ViewApi` has no orientation**, so an orbit camera cannot travel through
+  the kit's `view`. The kernel declares a `camera3d` dep of its own.
+- **`PoseDescriptor.remapBounds` and `fromBounds` throw.** A screen rectangle
+  does not name a 3D pose without a depth. `getBounds` and `intersectsRect` run
+  the other way and work, which is what drives selection chrome through an
+  orbit.
+
+## The bounds seam
+
+`World3d.bounds` is how a consumer says how big a node is. The kernel's default
+carries a unit cube by the pose; override it when a primitive knows better. A
+sphere is the case that forces the seam to be shaped this way — its box is the
+same under every rotation, and no transform of a local box reproduces that.
+
+## Math
+
+Vectors, quaternions, 4×4 matrices and ray intersection live in
+`@weasel-js/geom/3d` — the same dependency-free geometry package the 2D kit is
+built on. They are immutable tuples, not classes: `History.serialize()` promises
+a structured-clone-safe form, and `structuredClone` keeps a class instance's
+data while dropping its prototype, so a `Vector3` in a pose would return from a
+reload as a bare object whose first method call throws far from the cause.
+
+Interop with three.js is close to free anyway — `Vector3`, `Quaternion` and
+`Matrix4` all carry `fromArray`/`toArray` and agree with this layout.
+
+Direction: `docs/superpowers/specs/2026-08-22-3d-kernel-design.md`.

package/dist/index.d.ts

@@ -0,0 +1,287 @@
+import { Vec3, Mat4, Quat, Aabb, Ray } from '@weasel-js/geom/3d';
+import { SceneNode, Scene, NodeId, AreaSelectDep, InsertExtras, InsertDep, NodeAtPointDep, PoseDescriptor, SnapDep, OngoingHandle, Action, Tool } from '@weasel-js/core';
+
+/**
+ * An orbit camera: a target, two angles and a distance. Immutable — every
+ * gesture returns a new one, so it can live in instrument state.
+ *
+ * This is the shape `ViewApi` cannot hold, and the reason the kernel declares a
+ * `camera3d` dep of its own rather than reusing the kit's `view`.
+ */
+
+interface Camera3d {
+    target: Vec3;
+    /** Radians about +y, measured from +z. */
+    yaw: number;
+    /** Radians above the xz plane. */
+    pitch: number;
+    distance: number;
+    fov: number;
+    near: number;
+    far: number;
+}
+/** Short of vertical: at exactly ±π/2 the eye lands on the up axis and `lookAt` degenerates. */
+declare const MAX_PITCH: number;
+declare function createCamera(init: Partial<Camera3d>): Camera3d;
+declare function cameraEye(camera: Camera3d): Vec3;
+declare function cameraView(camera: Camera3d): Mat4;
+declare function cameraViewProjection(camera: Camera3d, aspect: number): Mat4;
+declare function orbitBy(camera: Camera3d, deltaYaw: number, deltaPitch: number): Camera3d;
+declare function dollyBy(camera: Camera3d, factor: number): Camera3d;
+
+/**
+ * A 3D pose, and the two things every consumer of one needs: its matrix, and
+ * the world box it occupies.
+ *
+ * `Scene<TData, TLayer, Pose3>` is the whole of how this reaches weasel —
+ * `Scene` is generic over its pose and holds this one with no adapter, no
+ * subclass and no special case.
+ */
+
+interface Pose3 {
+    position: Vec3;
+    rotation: Quat;
+    scale: Vec3;
+}
+/** The box a primitive occupies before its pose. A unit primitive centred on
+ *  its own origin — which is what the kernel assumes nothing about — is
+ *  `UNIT_CUBE`. */
+declare const UNIT_CUBE: Aabb;
+declare function pose3(position: Vec3, scale?: Vec3, rotation?: Quat): Pose3;
+declare function poseMatrix(pose: Pose3): Mat4;
+/**
+ * The world box a posed primitive occupies, given the box it occupies in its
+ * own space.
+ *
+ * Which local box a primitive has is the consumer's answer, not the kernel's:
+ * a sphere's is rotation-invariant and a mesh's comes from its vertices, and
+ * neither is something a pose can tell you.
+ */
+declare function aabbOfPose(pose: Pose3, local?: Aabb): Aabb;
+
+/**
+ * The screen side of the kernel: where a pointer points, and what rectangle a
+ * world box covers. This is the seam weasel's 2D chrome meets — everything
+ * here speaks `Bounds`-shaped screen rectangles, which is why a 3D host can
+ * pass the dispatcher's world point through unchanged.
+ */
+
+/** A pane's rectangle in CSS pixels, relative to the client. */
+interface ViewportRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** A screen rectangle in the shape core's `Bounds` uses. */
+interface ScreenBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A `ScreenBox` a host is being asked to outline. `tint` says why: warm for
+ *  what is selected, cool for what the gesture in hand is proposing. */
+interface ChromeBox extends ScreenBox {
+    tint?: 'selection' | 'gesture';
+}
+/** Screen point (y down, rect-relative) to normalized device coordinates (y up). */
+declare function screenToNdc(point: {
+    x: number;
+    y: number;
+}, rect: ViewportRect): {
+    x: number;
+    y: number;
+};
+declare function ndcToScreen(ndc: {
+    x: number;
+    y: number;
+}, rect: ViewportRect): {
+    x: number;
+    y: number;
+};
+/**
+ * The ray a screen point names, given the camera that drew the rect. This is
+ * the whole of what 3D picking needs from a pointer — which is why the world
+ * point the dispatcher carries stays two numbers.
+ */
+declare function rayThroughScreenPoint(point: {
+    x: number;
+    y: number;
+}, rect: ViewportRect, viewProjection: Mat4, eye: Vec3): Ray;
+/**
+ * The screen rectangle a world-space box covers — the currency weasel's chrome
+ * and `PoseDescriptor.getBounds` speak in. `null` when the box is entirely
+ * behind the near plane.
+ *
+ * Each of the twelve edges is clipped against the near plane before it is
+ * projected, rather than dropping the corners behind it. Dropping them reports
+ * a box that is too small for anything straddling the near plane, and the error
+ * grows as the camera moves in: a solid the pointer is inside of would outline
+ * as a sliver, or as nothing.
+ */
+declare function projectAabbToScreen(box: Aabb, viewProjection: Mat4, rect: ViewportRect): ScreenBox | null;
+
+/**
+ * The kit's deps, implemented against a 3D world.
+ *
+ * Every one of these takes its camera from a thunk rather than an argument.
+ * That is the kernel's central claim in code: the dispatcher keeps handing
+ * actions two numbers, and what makes them mean something in 3D is the camera
+ * each dep already closes over. `InvocationCtx` needs no widening, and none of
+ * these needs a ray passed in.
+ *
+ * Where a kit contract cannot be honored, the implementation throws rather than
+ * guessing. A guess would report a fit the kernel does not have.
+ */
+
+interface Viewport3d {
+    camera: Camera3d;
+    width: number;
+    height: number;
+    /**
+     * Where the pane sits in client coordinates. A 3D host works in one space
+     * from the event to the ray — it passes the dispatcher an identity
+     * `clientToWorld` — so the deps subtract this rather than the dispatcher.
+     */
+    originX?: number;
+    originY?: number;
+}
+type ViewportSource = () => Viewport3d;
+/** A 3D scene is core's scene with a `Pose3`. Nothing wraps it. */
+type Scene3d<TData, TLayer extends string> = Scene<TData, TLayer, Pose3>;
+type Node3d<TData, TLayer extends string> = SceneNode<TData, TLayer, Pose3>;
+/**
+ * The world box a node occupies. The kernel cannot answer this, and the reason
+ * is sharper than "it does not know the mesh": a sphere's box is the same under
+ * every rotation, and no transform of a local box reproduces that — rotate a
+ * cube and it widens. Asking for the world box directly is what lets a
+ * primitive answer for its own symmetry.
+ *
+ * Omitted, a node is a unit cube carried by its pose.
+ */
+type NodeBounds<TData, TLayer extends string> = (node: Node3d<TData, TLayer>) => Aabb;
+interface World3d<TData, TLayer extends string> {
+    scene: Scene3d<TData, TLayer>;
+    viewport: ViewportSource;
+    bounds?: NodeBounds<TData, TLayer>;
+    /** The axis gestures resolve against. Default `+y`. */
+    up?: Vec3;
+}
+/** The screen box a node covers, or null when it projects to nothing visible. */
+declare function screenBoxOf<TData, TLayer extends string>(world: World3d<TData, TLayer>, id: NodeId, viewport: Viewport3d): ScreenBox | null;
+/**
+ * Nearest node along the ray the screen point names.
+ *
+ * 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.
+ */
+declare function createNodeAtPoint<TData, TLayer extends string>(world: World3d<TData, TLayer>): NodeAtPointDep;
+/** Marquee: the nodes whose projected box the screen rectangle touches. */
+declare function createAreaSelect<TData, TLayer extends string>(world: World3d<TData, TLayer>, selection: {
+    get(): readonly NodeId[];
+    set(ids: NodeId[]): void;
+}): AreaSelectDep;
+/** No grid in 3D yet; the identity keeps `insertAction` happy without lying. */
+declare function createSnap(): SnapDep;
+/** The ground-plane rectangle a drag swept out, in world units. */
+interface Footprint {
+    /** Centre of the swept rectangle, on the ground plane. */
+    center: Vec3;
+    /** Extent along the two axes the up axis is not. */
+    width: number;
+    depth: number;
+}
+/**
+ * A drag rectangle becomes a footprint on the ground plane: its four corners
+ * are cast onto the plane and the hit points give the extent. What node that
+ * implies is the consumer's answer — the kernel does not know what it is
+ * inserting.
+ *
+ * The kit's `InsertDep.commit` hands over a screen-space AABB and nothing else,
+ * which turns out to be enough: the depth the 2D contract cannot express comes
+ * from the plane, not from the caller.
+ */
+declare function createInsert(opts: {
+    viewport: ViewportSource;
+    up?: Vec3;
+    /** Smallest footprint a click-sized drag produces. Default 0.25. */
+    minExtent?: number;
+    mint(footprint: Footprint, extras: InsertExtras): NodeId | null;
+}): InsertDep;
+/**
+ * `PoseDescriptor` over a 3D pose, with `Bounds` read as the screen box the
+ * node covers. Chrome and marquee math work unchanged; the two methods that
+ * run the other way cannot.
+ *
+ * `forNode` is what lets a sphere bound itself as a sphere: every node is a
+ * `Pose3`, so the shape lives on `node.data` and nothing but the node can say
+ * which one this is. Unspecialized — the kit calling with only a pose in hand —
+ * it answers with the default local box, which is the looser of the two.
+ *
+ * The contract mismatch that remains, recorded in the kernel doc: a screen
+ * rectangle does not name a 3D pose without a depth, so `remapBounds` and
+ * `fromBounds` have no honest answer.
+ */
+declare function createPoseDescriptor<TData, TLayer extends string>(world: World3d<TData, TLayer>): PoseDescriptor<Pose3, Node3d<TData, TLayer>>;
+
+/**
+ * What a host paints for a gesture that proposes chrome rather than a pose.
+ *
+ * A marquee sweep and a box-drag both publish an `OngoingOverlay`, which used
+ * to reach paint only through core's own 2D layer. `resolveOverlays` hands back
+ * world geometry with no renderer in it, so the same call `<SceneCanvas>` makes
+ * serves a consumer-owned 3D renderer.
+ *
+ * A 3D host's `clientToWorld` is identity, so an overlay's world bounds are the
+ * client rect the deps already work in, and the pane origin comes off exactly
+ * once. Only the rectangular variants resolve here: a lasso, a pencil and a run
+ * of points are paths, and a path is geometry this cannot flatten to a box.
+ */
+
+/** Gesture chrome, in CSS pixels relative to the pane's top-left. */
+declare function collectOverlayBoxes(handles: Iterable<OngoingHandle>, origin: {
+    x: number;
+    y: number;
+}): ChromeBox[];
+
+/**
+ * Camera tools and their actions.
+ *
+ * Shape tools transfer from the kit untouched — a 3D host mounts core's own
+ * `useSelectTool` and a rectangle-style insert binding and neither notices the
+ * dimension. Only the viewport tools are written here, which is the one
+ * exception the kernel doc predicted: `useHandTool` routes to
+ * `viewport.dragPan`, and that wants the 2D `view`.
+ */
+
+declare const orbitAction: Action;
+declare const dollyAction: Action;
+declare function useOrbitTool(): Tool<null>;
+
+/**
+ * The kernel's one new dep.
+ *
+ * `ViewApi` is pan and scale with no orientation, so an orbit camera cannot
+ * travel through the kit's `view`. It gets a slot of its own, declared the way
+ * any consumer declares one — which is the only place the kernel asks core for
+ * anything core does not already offer.
+ */
+
+interface Camera3dDep {
+    get(): Camera3d;
+    set(camera: Camera3d): void;
+    /** Pane size in CSS pixels — what turns a screen point into a ray. */
+    size(): {
+        width: number;
+        height: number;
+    };
+}
+declare module '@weasel-js/core' {
+    interface DepSchema {
+        camera3d?: Camera3dDep;
+    }
+}
+
+export { type Camera3d, type Camera3dDep, type ChromeBox, type Footprint, MAX_PITCH, type Node3d, type NodeBounds, type Pose3, type Scene3d, type ScreenBox, UNIT_CUBE, type Viewport3d, type ViewportRect, type ViewportSource, type World3d, aabbOfPose, cameraEye, cameraView, cameraViewProjection, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, ndcToScreen, orbitAction, orbitBy, pose3, poseMatrix, projectAabbToScreen, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool };

package/dist/index.js

@@ -0,0 +1,392 @@
+import { lookAt, multiply, perspective, quatIdentity, compose, transformAabb, invert, transformPoint, normalize, sub, transformPoint4, intersectRayAabb, intersectRayPlane } from '@weasel-js/geom/3d';
+import { resolveOverlays, defineTool } from '@weasel-js/core';
+
+// src/camera.ts
+var MAX_PITCH = Math.PI / 2 - 0.01;
+var MIN_DISTANCE = 0.5;
+var MAX_DISTANCE = 500;
+var UP = [0, 1, 0];
+function createCamera(init) {
+  return {
+    target: init.target ?? [0, 0, 0],
+    yaw: init.yaw ?? 0,
+    pitch: init.pitch ?? 0,
+    distance: init.distance ?? 10,
+    fov: init.fov ?? Math.PI / 4,
+    near: init.near ?? 0.1,
+    far: init.far ?? 1e3
+  };
+}
+function cameraEye(camera) {
+  const { target, yaw, pitch, distance } = camera;
+  const horizontal = Math.cos(pitch) * distance;
+  return [
+    target[0] + horizontal * Math.sin(yaw),
+    target[1] + Math.sin(pitch) * distance,
+    target[2] + horizontal * Math.cos(yaw)
+  ];
+}
+function cameraView(camera) {
+  return lookAt(cameraEye(camera), camera.target, UP);
+}
+function cameraViewProjection(camera, aspect) {
+  return multiply(perspective(camera.fov, aspect, camera.near, camera.far), cameraView(camera));
+}
+function orbitBy(camera, deltaYaw, deltaPitch) {
+  return {
+    ...camera,
+    yaw: camera.yaw + deltaYaw,
+    pitch: Math.max(-MAX_PITCH, Math.min(MAX_PITCH, camera.pitch + deltaPitch))
+  };
+}
+function dollyBy(camera, factor) {
+  return {
+    ...camera,
+    distance: Math.max(MIN_DISTANCE, Math.min(MAX_DISTANCE, camera.distance * factor))
+  };
+}
+var UNIT_CUBE = { min: [-0.5, -0.5, -0.5], max: [0.5, 0.5, 0.5] };
+function pose3(position, scale = [1, 1, 1], rotation = quatIdentity()) {
+  return { position, rotation, scale };
+}
+function poseMatrix(pose) {
+  return compose(pose.position, pose.rotation, pose.scale);
+}
+function aabbOfPose(pose, local = UNIT_CUBE) {
+  return transformAabb(poseMatrix(pose), local);
+}
+var EPS = 1e-9;
+function screenToNdc(point, rect) {
+  return {
+    x: (point.x - rect.x) / rect.w * 2 - 1,
+    y: 1 - (point.y - rect.y) / rect.h * 2
+  };
+}
+function ndcToScreen(ndc, rect) {
+  return {
+    x: rect.x + (ndc.x * 0.5 + 0.5) * rect.w,
+    y: rect.y + (1 - (ndc.y * 0.5 + 0.5)) * rect.h
+  };
+}
+function rayThroughScreenPoint(point, rect, viewProjection, eye) {
+  const inv = invert(viewProjection);
+  if (!inv) return { origin: eye, direction: [0, 0, -1] };
+  const ndc = screenToNdc(point, rect);
+  const near = transformPoint(inv, [ndc.x, ndc.y, -1]);
+  const far = transformPoint(inv, [ndc.x, ndc.y, 1]);
+  return { origin: eye, direction: normalize(sub(far, near)) };
+}
+function nearSide(p) {
+  return p[2] + p[3];
+}
+function lerpClip(a, b, t) {
+  return [
+    a[0] + (b[0] - a[0]) * t,
+    a[1] + (b[1] - a[1]) * t,
+    a[2] + (b[2] - a[2]) * t,
+    a[3] + (b[3] - a[3]) * t
+  ];
+}
+var EDGE_BITS = [1, 2, 4];
+function projectAabbToScreen(box, viewProjection, rect) {
+  const corners = [];
+  for (let i = 0; i < 8; i++) {
+    const corner = [
+      i & 1 ? box.max[0] : box.min[0],
+      i & 2 ? box.max[1] : box.min[1],
+      i & 4 ? box.max[2] : box.min[2]
+    ];
+    corners.push(transformPoint4(viewProjection, corner));
+  }
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  let any = false;
+  const extend = (p) => {
+    if (p[3] <= EPS) return;
+    const screen = ndcToScreen({ x: p[0] / p[3], y: p[1] / p[3] }, rect);
+    minX = Math.min(minX, screen.x);
+    minY = Math.min(minY, screen.y);
+    maxX = Math.max(maxX, screen.x);
+    maxY = Math.max(maxY, screen.y);
+    any = true;
+  };
+  for (let i = 0; i < 8; i++) {
+    for (const bit of EDGE_BITS) {
+      if (i & bit) continue;
+      let a = corners[i];
+      let b = corners[i | bit];
+      const da = nearSide(a);
+      const db = nearSide(b);
+      if (da < 0 && db < 0) continue;
+      if (da < 0) a = lerpClip(a, b, da / (da - db));
+      else if (db < 0) b = lerpClip(b, a, db / (db - da));
+      extend(a);
+      extend(b);
+    }
+  }
+  if (!any) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+var DEFAULT_UP = [0, 1, 0];
+function boundsOfNode(world, node) {
+  return world.bounds ? world.bounds(node) : aabbOfPose(node.pose);
+}
+function rectOf(viewport) {
+  return {
+    x: viewport.originX ?? 0,
+    y: viewport.originY ?? 0,
+    w: viewport.width,
+    h: viewport.height
+  };
+}
+function viewProjectionOf(viewport) {
+  return cameraViewProjection(viewport.camera, viewport.width / Math.max(1, viewport.height));
+}
+function rayAt(viewport, point) {
+  return rayThroughScreenPoint(
+    point,
+    rectOf(viewport),
+    viewProjectionOf(viewport),
+    cameraEye(viewport.camera)
+  );
+}
+function pointOnRay(ray, t) {
+  return [
+    ray.origin[0] + ray.direction[0] * t,
+    ray.origin[1] + ray.direction[1] * t,
+    ray.origin[2] + ray.direction[2] * t
+  ];
+}
+function overlaps(a, b) {
+  return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+function screenBoxOf(world, id, viewport) {
+  const node = world.scene.get(id);
+  if (!node) return null;
+  return projectAabbToScreen(
+    boundsOfNode(world, node),
+    viewProjectionOf(viewport),
+    rectOf(viewport)
+  );
+}
+function createNodeAtPoint(world) {
+  return (point, exclude) => {
+    const excluded = exclude ? new Set(exclude) : null;
+    const vp = world.viewport();
+    const ray = rayAt(vp, point);
+    let best = null;
+    let bestT = Infinity;
+    for (const node of world.scene.renderOrderNodes()) {
+      if (excluded?.has(node.id)) continue;
+      const { min, max } = boundsOfNode(world, node);
+      const t = intersectRayAabb(ray, min, max);
+      if (t !== null && t < bestT) {
+        bestT = t;
+        best = node.id;
+      }
+    }
+    return best;
+  };
+}
+function createAreaSelect(world, selection) {
+  return {
+    hitTestArea(bounds) {
+      const vp = world.viewport();
+      const hits = [];
+      for (const node of world.scene.renderOrderNodes()) {
+        const box = screenBoxOf(world, node.id, vp);
+        if (box && overlaps(box, bounds)) hits.push(node.id);
+      }
+      return hits;
+    },
+    getSelection: () => [...selection.get()],
+    setSelection: (ids) => selection.set([...ids])
+  };
+}
+function createSnap() {
+  return { point: (p) => p };
+}
+function createInsert(opts) {
+  const up = opts.up ?? DEFAULT_UP;
+  const minExtent = opts.minExtent ?? 0.25;
+  const axes = up[1] !== 0 ? [0, 2] : up[0] !== 0 ? [1, 2] : [0, 1];
+  return {
+    commit(bounds, extras) {
+      const vp = opts.viewport();
+      const corners = [
+        { x: bounds.x, y: bounds.y },
+        { x: bounds.x + bounds.width, y: bounds.y },
+        { x: bounds.x, y: bounds.y + bounds.height },
+        { x: bounds.x + bounds.width, y: bounds.y + bounds.height }
+      ];
+      const hits = [];
+      for (const corner of corners) {
+        const ray = rayAt(vp, corner);
+        const t = intersectRayPlane(ray, up, 0);
+        if (t !== null) hits.push(pointOnRay(ray, t));
+      }
+      if (hits.length === 0) return null;
+      const [u, v] = axes;
+      let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
+      for (const h of hits) {
+        minU = Math.min(minU, h[u]);
+        maxU = Math.max(maxU, h[u]);
+        minV = Math.min(minV, h[v]);
+        maxV = Math.max(maxV, h[v]);
+      }
+      const center = [0, 0, 0];
+      center[u] = (minU + maxU) / 2;
+      center[v] = (minV + maxV) / 2;
+      return opts.mint(
+        {
+          center,
+          width: Math.max(minExtent, maxU - minU),
+          depth: Math.max(minExtent, maxV - minV)
+        },
+        extras
+      );
+    }
+  };
+}
+function createPoseDescriptor(world) {
+  const up = world.up ?? DEFAULT_UP;
+  const upAxis = up[1] !== 0 ? 1 : up[0] !== 0 ? 0 : 2;
+  const specialized = /* @__PURE__ */ new WeakMap();
+  function build(worldBox) {
+    const boundsOf = (pose) => {
+      const vp = world.viewport();
+      return projectAabbToScreen(worldBox(pose), viewProjectionOf(vp), rectOf(vp));
+    };
+    const descriptor = {
+      forNode(node) {
+        let d = specialized.get(node);
+        if (!d) {
+          d = build((pose) => boundsOfNode(world, { ...node, pose }));
+          specialized.set(node, d);
+        }
+        return d;
+      },
+      getBounds(pose) {
+        return boundsOf(pose) ?? { x: 0, y: 0, width: 0, height: 0 };
+      },
+      remapBounds() {
+        throw new Error(
+          "kernel3d: remapBounds has no 3D answer \u2014 a screen rectangle does not name a pose without a depth."
+        );
+      },
+      fromBounds() {
+        throw new Error(
+          "kernel3d: fromBounds has no 3D answer \u2014 a screen rectangle does not name a pose without a depth."
+        );
+      },
+      /**
+       * Screen-space deltas resolve against the plane the node already sits on,
+       * so the two numbers the kit passes are enough: the camera that turns
+       * them into a world position is the one this dep closed over.
+       */
+      translate(pose, dx, dy) {
+        const vp = world.viewport();
+        const box = boundsOf(pose);
+        if (!box) return pose;
+        const from = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+        const to = { x: from.x + dx, y: from.y + dy };
+        const offset = pose.position[upAxis];
+        const ray = rayAt(vp, to);
+        const t = intersectRayPlane(ray, up, offset);
+        if (t === null) return pose;
+        const anchorRay = rayAt(vp, from);
+        const anchorT = intersectRayPlane(anchorRay, up, offset);
+        if (anchorT === null) return pose;
+        const delta = sub(pointOnRay(ray, t), pointOnRay(anchorRay, anchorT));
+        const position = [
+          pose.position[0] + delta[0],
+          pose.position[1] + delta[1],
+          pose.position[2] + delta[2]
+        ];
+        position[upAxis] = pose.position[upAxis];
+        return { ...pose, position };
+      },
+      intersectsRect(pose, rect) {
+        const box = boundsOf(pose);
+        return box ? overlaps(box, rect) : false;
+      },
+      supportsRotation() {
+        return false;
+      }
+    };
+    return descriptor;
+  }
+  return build((pose) => aabbOfPose(pose));
+}
+function collectOverlayBoxes(handles, origin) {
+  const overlays = [];
+  for (const handle of handles) {
+    const ov = handle.overlay?.();
+    if (ov) overlays.push(ov);
+  }
+  const boxes = [];
+  for (const resolved of resolveOverlays(overlays)) {
+    if (resolved.kind !== "marquee" && resolved.kind !== "insertPreview") continue;
+    const { x, y, width, height } = resolved.bounds;
+    boxes.push({ x: x - origin.x, y: y - origin.y, width, height, tint: "gesture" });
+  }
+  return boxes;
+}
+var ORBIT_RATE = 6e-3;
+var DOLLY_RATE = 15e-4;
+function cameraDep(deps) {
+  return deps.camera3d;
+}
+var orbitAction = {
+  id: "camera.orbit",
+  label: "Orbit",
+  requires: ["camera3d"],
+  invoker: {
+    timing: "ongoing",
+    start(ctx) {
+      const dep = cameraDep(ctx.deps);
+      const origin = dep?.get();
+      return {
+        kind: "orbit",
+        onMove(move) {
+          if (!dep || !origin) return;
+          const delta = move.drag?.screenDelta ?? move.drag?.delta;
+          if (!delta) return;
+          dep.set(orbitBy(origin, -delta.x * ORBIT_RATE, delta.y * ORBIT_RATE));
+        }
+      };
+    }
+  }
+};
+var dollyAction = {
+  id: "camera.dolly",
+  label: "Dolly",
+  group: "viewport",
+  // Wheel, in any tool — the dispatcher merges the event's deltas into params.
+  defaultBinding: [{ spec: { kind: "wheel" }, opts: {} }],
+  requires: ["camera3d"],
+  invoker: {
+    timing: "immediate",
+    run(deps, params) {
+      const dep = cameraDep(deps);
+      if (!dep) return;
+      const amount = typeof params?.deltaY === "number" ? params.deltaY : 0;
+      dep.set(dollyBy(dep.get(), Math.exp(amount * DOLLY_RATE)));
+    }
+  }
+};
+function useOrbitTool() {
+  return defineTool({
+    id: "orbit",
+    hookName: "useOrbitTool",
+    cursor: "grab",
+    presentation: { label: "Orbit", group: "viewport" },
+    bindings: [{ spec: { kind: "drag" }, actionId: "camera.orbit" }]
+  });
+}
+
+export { MAX_PITCH, UNIT_CUBE, aabbOfPose, cameraEye, cameraView, cameraViewProjection, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, ndcToScreen, orbitAction, orbitBy, pose3, poseMatrix, projectAabbToScreen, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/camera.ts","../src/pose3.ts","../src/screen.ts","../src/deps.ts","../src/overlays.ts","../src/tools.ts"],"names":["sub"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * An orbit camera: a target, two angles and a distance. Immutable — every\n * gesture returns a new one, so it can live in instrument state.\n *\n * This is the shape `ViewApi` cannot hold, and the reason the kernel declares a\n * `camera3d` dep of its own rather than reusing the kit's `view`.\n */\n\nimport {\n  lookAt,\n  multiply,\n  perspective,\n  type Mat4,\n  type Vec3,\n} from '@weasel-js/geom/3d';\n\nexport interface Camera3d {\n  target: Vec3;\n  /** Radians about +y, measured from +z. */\n  yaw: number;\n  /** Radians above the xz plane. */\n  pitch: number;\n  distance: number;\n  fov: number;\n  near: number;\n  far: number;\n}\n\n/** Short of vertical: at exactly ±π/2 the eye lands on the up axis and `lookAt` degenerates. */\nexport const MAX_PITCH = Math.PI / 2 - 0.01;\nconst MIN_DISTANCE = 0.5;\nconst MAX_DISTANCE = 500;\nconst UP: Vec3 = [0, 1, 0];\n\nexport function createCamera(init: Partial<Camera3d>): Camera3d {\n  return {\n    target: init.target ?? [0, 0, 0],\n    yaw: init.yaw ?? 0,\n    pitch: init.pitch ?? 0,\n    distance: init.distance ?? 10,\n    fov: init.fov ?? Math.PI / 4,\n    near: init.near ?? 0.1,\n    far: init.far ?? 1000,\n  };\n}\n\nexport function cameraEye(camera: Camera3d): Vec3 {\n  const { target, yaw, pitch, distance } = camera;\n  const horizontal = Math.cos(pitch) * distance;\n  return [\n    target[0] + horizontal * Math.sin(yaw),\n    target[1] + Math.sin(pitch) * distance,\n    target[2] + horizontal * Math.cos(yaw),\n  ];\n}\n\nexport function cameraView(camera: Camera3d): Mat4 {\n  return lookAt(cameraEye(camera), camera.target, UP);\n}\n\nexport function cameraViewProjection(camera: Camera3d, aspect: number): Mat4 {\n  return multiply(perspective(camera.fov, aspect, camera.near, camera.far), cameraView(camera));\n}\n\nexport function orbitBy(camera: Camera3d, deltaYaw: number, deltaPitch: number): Camera3d {\n  return {\n    ...camera,\n    yaw: camera.yaw + deltaYaw,\n    pitch: Math.max(-MAX_PITCH, Math.min(MAX_PITCH, camera.pitch + deltaPitch)),\n  };\n}\n\nexport function dollyBy(camera: Camera3d, factor: number): Camera3d {\n  return {\n    ...camera,\n    distance: Math.max(MIN_DISTANCE, Math.min(MAX_DISTANCE, camera.distance * factor)),\n  };\n}\n","/**\n * A 3D pose, and the two things every consumer of one needs: its matrix, and\n * the world box it occupies.\n *\n * `Scene<TData, TLayer, Pose3>` is the whole of how this reaches weasel —\n * `Scene` is generic over its pose and holds this one with no adapter, no\n * subclass and no special case.\n */\n\nimport {\n  compose, quatIdentity, transformAabb, type Aabb, type Mat4, type Quat, type Vec3,\n} from '@weasel-js/geom/3d';\n\nexport interface Pose3 {\n  position: Vec3;\n  rotation: Quat;\n  scale: Vec3;\n}\n\n/** The box a primitive occupies before its pose. A unit primitive centred on\n *  its own origin — which is what the kernel assumes nothing about — is\n *  `UNIT_CUBE`. */\nexport const UNIT_CUBE: Aabb = { min: [-0.5, -0.5, -0.5], max: [0.5, 0.5, 0.5] };\n\nexport function pose3(\n  position: Vec3,\n  scale: Vec3 = [1, 1, 1],\n  rotation: Quat = quatIdentity(),\n): Pose3 {\n  return { position, rotation, scale };\n}\n\nexport function poseMatrix(pose: Pose3): Mat4 {\n  return compose(pose.position, pose.rotation, pose.scale);\n}\n\n/**\n * The world box a posed primitive occupies, given the box it occupies in its\n * own space.\n *\n * Which local box a primitive has is the consumer's answer, not the kernel's:\n * a sphere's is rotation-invariant and a mesh's comes from its vertices, and\n * neither is something a pose can tell you.\n */\nexport function aabbOfPose(pose: Pose3, local: Aabb = UNIT_CUBE): Aabb {\n  return transformAabb(poseMatrix(pose), local);\n}\n","/**\n * The screen side of the kernel: where a pointer points, and what rectangle a\n * world box covers. This is the seam weasel's 2D chrome meets — everything\n * here speaks `Bounds`-shaped screen rectangles, which is why a 3D host can\n * pass the dispatcher's world point through unchanged.\n */\n\nimport {\n  invert,\n  normalize,\n  sub,\n  transformPoint,\n  transformPoint4,\n  type Aabb,\n  type Mat4,\n  type Ray,\n  type Vec3,\n} from '@weasel-js/geom/3d';\n\n/** A pane's rectangle in CSS pixels, relative to the client. */\nexport interface ViewportRect {\n  x: number;\n  y: number;\n  w: number;\n  h: number;\n}\n\n/** A screen rectangle in the shape core's `Bounds` uses. */\nexport interface ScreenBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** A `ScreenBox` a host is being asked to outline. `tint` says why: warm for\n *  what is selected, cool for what the gesture in hand is proposing. */\nexport interface ChromeBox extends ScreenBox {\n  tint?: 'selection' | 'gesture';\n}\n\nconst EPS = 1e-9;\n\n/** Screen point (y down, rect-relative) to normalized device coordinates (y up). */\nexport function screenToNdc(\n  point: { x: number; y: number },\n  rect: ViewportRect,\n): { x: number; y: number } {\n  return {\n    x: ((point.x - rect.x) / rect.w) * 2 - 1,\n    y: 1 - ((point.y - rect.y) / rect.h) * 2,\n  };\n}\n\nexport function ndcToScreen(\n  ndc: { x: number; y: number },\n  rect: ViewportRect,\n): { x: number; y: number } {\n  return {\n    x: rect.x + (ndc.x * 0.5 + 0.5) * rect.w,\n    y: rect.y + (1 - (ndc.y * 0.5 + 0.5)) * rect.h,\n  };\n}\n\n/**\n * The ray a screen point names, given the camera that drew the rect. This is\n * the whole of what 3D picking needs from a pointer — which is why the world\n * point the dispatcher carries stays two numbers.\n */\nexport function rayThroughScreenPoint(\n  point: { x: number; y: number },\n  rect: ViewportRect,\n  viewProjection: Mat4,\n  eye: Vec3,\n): Ray {\n  const inv = invert(viewProjection);\n  if (!inv) return { origin: eye, direction: [0, 0, -1] };\n  const ndc = screenToNdc(point, rect);\n  const near = transformPoint(inv, [ndc.x, ndc.y, -1]);\n  const far = transformPoint(inv, [ndc.x, ndc.y, 1]);\n  return { origin: eye, direction: normalize(sub(far, near)) };\n}\n\ntype Clip = readonly [number, number, number, number];\n\n/** Signed distance to the near plane in clip space; `>= 0` is in front of it.\n *  GL puts the near plane at `z = -w`. */\nfunction nearSide(p: Clip): number {\n  return p[2] + p[3];\n}\n\nfunction lerpClip(a: Clip, b: Clip, t: number): Clip {\n  return [\n    a[0] + (b[0] - a[0]) * t,\n    a[1] + (b[1] - a[1]) * t,\n    a[2] + (b[2] - a[2]) * t,\n    a[3] + (b[3] - a[3]) * t,\n  ];\n}\n\n/** The three edges leaving corner `i` toward a higher bit, as bit masks. */\nconst EDGE_BITS = [1, 2, 4] as const;\n\n/**\n * The screen rectangle a world-space box covers — the currency weasel's chrome\n * and `PoseDescriptor.getBounds` speak in. `null` when the box is entirely\n * behind the near plane.\n *\n * Each of the twelve edges is clipped against the near plane before it is\n * projected, rather than dropping the corners behind it. Dropping them reports\n * a box that is too small for anything straddling the near plane, and the error\n * grows as the camera moves in: a solid the pointer is inside of would outline\n * as a sliver, or as nothing.\n */\nexport function projectAabbToScreen(\n  box: Aabb,\n  viewProjection: Mat4,\n  rect: ViewportRect,\n): ScreenBox | null {\n  const corners: Clip[] = [];\n  for (let i = 0; i < 8; i++) {\n    const corner: Vec3 = [\n      i & 1 ? box.max[0] : box.min[0],\n      i & 2 ? box.max[1] : box.min[1],\n      i & 4 ? box.max[2] : box.min[2],\n    ];\n    corners.push(transformPoint4(viewProjection, corner));\n  }\n\n  let minX = Number.POSITIVE_INFINITY;\n  let minY = Number.POSITIVE_INFINITY;\n  let maxX = Number.NEGATIVE_INFINITY;\n  let maxY = Number.NEGATIVE_INFINITY;\n  let any = false;\n\n  const extend = (p: Clip): void => {\n    if (p[3] <= EPS) return;\n    const screen = ndcToScreen({ x: p[0] / p[3], y: p[1] / p[3] }, rect);\n    minX = Math.min(minX, screen.x);\n    minY = Math.min(minY, screen.y);\n    maxX = Math.max(maxX, screen.x);\n    maxY = Math.max(maxY, screen.y);\n    any = true;\n  };\n\n  for (let i = 0; i < 8; i++) {\n    for (const bit of EDGE_BITS) {\n      if (i & bit) continue;\n      let a = corners[i];\n      let b = corners[i | bit];\n      const da = nearSide(a);\n      const db = nearSide(b);\n      if (da < 0 && db < 0) continue;\n      if (da < 0) a = lerpClip(a, b, da / (da - db));\n      else if (db < 0) b = lerpClip(b, a, db / (db - da));\n      extend(a);\n      extend(b);\n    }\n  }\n\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n","/**\n * The kit's deps, implemented against a 3D world.\n *\n * Every one of these takes its camera from a thunk rather than an argument.\n * That is the kernel's central claim in code: the dispatcher keeps handing\n * actions two numbers, and what makes them mean something in 3D is the camera\n * each dep already closes over. `InvocationCtx` needs no widening, and none of\n * these needs a ray passed in.\n *\n * Where a kit contract cannot be honored, the implementation throws rather than\n * guessing. A guess would report a fit the kernel does not have.\n */\n\nimport type {\n  AreaSelectDep,\n  InsertDep,\n  InsertExtras,\n  NodeAtPointDep,\n  NodeId,\n  PoseDescriptor,\n  Scene,\n  SceneNode,\n  SnapDep,\n} from '@weasel-js/core';\nimport {\n  intersectRayAabb,\n  intersectRayPlane,\n  sub,\n  type Aabb,\n  type Ray,\n  type Vec3,\n} from '@weasel-js/geom/3d';\nimport { cameraEye, cameraViewProjection, type Camera3d } from './camera';\nimport { aabbOfPose, type Pose3 } from './pose3';\nimport {\n  projectAabbToScreen,\n  rayThroughScreenPoint,\n  type ScreenBox,\n  type ViewportRect,\n} from './screen';\n\nexport interface Viewport3d {\n  camera: Camera3d;\n  width: number;\n  height: number;\n  /**\n   * Where the pane sits in client coordinates. A 3D host works in one space\n   * from the event to the ray — it passes the dispatcher an identity\n   * `clientToWorld` — so the deps subtract this rather than the dispatcher.\n   */\n  originX?: number;\n  originY?: number;\n}\n\nexport type ViewportSource = () => Viewport3d;\n\n/** A 3D scene is core's scene with a `Pose3`. Nothing wraps it. */\nexport type Scene3d<TData, TLayer extends string> = Scene<TData, TLayer, Pose3>;\nexport type Node3d<TData, TLayer extends string> = SceneNode<TData, TLayer, Pose3>;\n\n/**\n * The world box a node occupies. The kernel cannot answer this, and the reason\n * is sharper than \"it does not know the mesh\": a sphere's box is the same under\n * every rotation, and no transform of a local box reproduces that — rotate a\n * cube and it widens. Asking for the world box directly is what lets a\n * primitive answer for its own symmetry.\n *\n * Omitted, a node is a unit cube carried by its pose.\n */\nexport type NodeBounds<TData, TLayer extends string> = (\n  node: Node3d<TData, TLayer>,\n) => Aabb;\n\nexport interface World3d<TData, TLayer extends string> {\n  scene: Scene3d<TData, TLayer>;\n  viewport: ViewportSource;\n  bounds?: NodeBounds<TData, TLayer>;\n  /** The axis gestures resolve against. Default `+y`. */\n  up?: Vec3;\n}\n\nconst DEFAULT_UP: Vec3 = [0, 1, 0];\n\nfunction boundsOfNode<TData, TLayer extends string>(\n  world: World3d<TData, TLayer>,\n  node: Node3d<TData, TLayer>,\n): Aabb {\n  return world.bounds ? world.bounds(node) : aabbOfPose(node.pose);\n}\n\n/** The pane, in the coordinate space the host's points arrive in. */\nfunction rectOf(viewport: Viewport3d): ViewportRect {\n  return {\n    x: viewport.originX ?? 0,\n    y: viewport.originY ?? 0,\n    w: viewport.width,\n    h: viewport.height,\n  };\n}\n\nfunction viewProjectionOf(viewport: Viewport3d) {\n  return cameraViewProjection(viewport.camera, viewport.width / Math.max(1, viewport.height));\n}\n\nfunction rayAt(viewport: Viewport3d, point: { x: number; y: number }): Ray {\n  return rayThroughScreenPoint(\n    point,\n    rectOf(viewport),\n    viewProjectionOf(viewport),\n    cameraEye(viewport.camera),\n  );\n}\n\nfunction pointOnRay(ray: Ray, t: number): Vec3 {\n  return [\n    ray.origin[0] + ray.direction[0] * t,\n    ray.origin[1] + ray.direction[1] * t,\n    ray.origin[2] + ray.direction[2] * t,\n  ];\n}\n\nfunction overlaps(a: ScreenBox, b: ScreenBox): boolean {\n  return (\n    a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y\n  );\n}\n\n/** The screen box a node covers, or null when it projects to nothing visible. */\nexport function screenBoxOf<TData, TLayer extends string>(\n  world: World3d<TData, TLayer>,\n  id: NodeId,\n  viewport: Viewport3d,\n): ScreenBox | null {\n  const node = world.scene.get(id) as Node3d<TData, TLayer> | undefined;\n  if (!node) return null;\n  return projectAabbToScreen(\n    boundsOfNode(world, node),\n    viewProjectionOf(viewport),\n    rectOf(viewport),\n  );\n}\n\n/**\n * Nearest node along the ray the screen point names.\n *\n * The kit calls this with what it believes is a world point; a 3D host feeds\n * the dispatcher an identity `clientToWorld`, so it is the pane-relative screen\n * point, which is exactly what a ray needs.\n */\nexport function createNodeAtPoint<TData, TLayer extends string>(\n  world: World3d<TData, TLayer>,\n): NodeAtPointDep {\n  return (point, exclude) => {\n    const excluded = exclude ? new Set(exclude) : null;\n    const vp = world.viewport();\n    const ray = rayAt(vp, point);\n    let best: NodeId | null = null;\n    let bestT = Infinity;\n    for (const node of world.scene.renderOrderNodes() as readonly Node3d<TData, TLayer>[]) {\n      if (excluded?.has(node.id)) continue;\n      const { min, max } = boundsOfNode(world, node);\n      const t = intersectRayAabb(ray, min, max);\n      if (t !== null && t < bestT) {\n        bestT = t;\n        best = node.id;\n      }\n    }\n    return best;\n  };\n}\n\n/** Marquee: the nodes whose projected box the screen rectangle touches. */\nexport function createAreaSelect<TData, TLayer extends string>(\n  world: World3d<TData, TLayer>,\n  selection: { get(): readonly NodeId[]; set(ids: NodeId[]): void },\n): AreaSelectDep {\n  return {\n    hitTestArea(bounds) {\n      const vp = world.viewport();\n      const hits: NodeId[] = [];\n      for (const node of world.scene.renderOrderNodes()) {\n        const box = screenBoxOf(world, node.id, vp);\n        if (box && overlaps(box, bounds)) hits.push(node.id);\n      }\n      return hits;\n    },\n    getSelection: () => [...selection.get()],\n    setSelection: (ids) => selection.set([...ids]),\n  };\n}\n\n/** No grid in 3D yet; the identity keeps `insertAction` happy without lying. */\nexport function createSnap(): SnapDep {\n  return { point: (p) => p };\n}\n\n/** The ground-plane rectangle a drag swept out, in world units. */\nexport interface Footprint {\n  /** Centre of the swept rectangle, on the ground plane. */\n  center: Vec3;\n  /** Extent along the two axes the up axis is not. */\n  width: number;\n  depth: number;\n}\n\n/**\n * A drag rectangle becomes a footprint on the ground plane: its four corners\n * are cast onto the plane and the hit points give the extent. What node that\n * implies is the consumer's answer — the kernel does not know what it is\n * inserting.\n *\n * The kit's `InsertDep.commit` hands over a screen-space AABB and nothing else,\n * which turns out to be enough: the depth the 2D contract cannot express comes\n * from the plane, not from the caller.\n */\nexport function createInsert(opts: {\n  viewport: ViewportSource;\n  up?: Vec3;\n  /** Smallest footprint a click-sized drag produces. Default 0.25. */\n  minExtent?: number;\n  mint(footprint: Footprint, extras: InsertExtras): NodeId | null;\n}): InsertDep {\n  const up = opts.up ?? DEFAULT_UP;\n  const minExtent = opts.minExtent ?? 0.25;\n  // The two axes the up axis is not, so a footprint reads the same whichever\n  // way up the world is.\n  const axes: [number, number] = up[1] !== 0 ? [0, 2] : up[0] !== 0 ? [1, 2] : [0, 1];\n\n  return {\n    commit(bounds, extras) {\n      const vp = opts.viewport();\n      const corners = [\n        { x: bounds.x, y: bounds.y },\n        { x: bounds.x + bounds.width, y: bounds.y },\n        { x: bounds.x, y: bounds.y + bounds.height },\n        { x: bounds.x + bounds.width, y: bounds.y + bounds.height },\n      ];\n\n      const hits: Vec3[] = [];\n      for (const corner of corners) {\n        const ray = rayAt(vp, corner);\n        const t = intersectRayPlane(ray, up, 0);\n        if (t !== null) hits.push(pointOnRay(ray, t));\n      }\n      if (hits.length === 0) return null;\n\n      const [u, v] = axes;\n      let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;\n      for (const h of hits) {\n        minU = Math.min(minU, h[u]); maxU = Math.max(maxU, h[u]);\n        minV = Math.min(minV, h[v]); maxV = Math.max(maxV, h[v]);\n      }\n\n      const center: [number, number, number] = [0, 0, 0];\n      center[u] = (minU + maxU) / 2;\n      center[v] = (minV + maxV) / 2;\n      return opts.mint(\n        {\n          center,\n          width: Math.max(minExtent, maxU - minU),\n          depth: Math.max(minExtent, maxV - minV),\n        },\n        extras,\n      );\n    },\n  };\n}\n\n/**\n * `PoseDescriptor` over a 3D pose, with `Bounds` read as the screen box the\n * node covers. Chrome and marquee math work unchanged; the two methods that\n * run the other way cannot.\n *\n * `forNode` is what lets a sphere bound itself as a sphere: every node is a\n * `Pose3`, so the shape lives on `node.data` and nothing but the node can say\n * which one this is. Unspecialized — the kit calling with only a pose in hand —\n * it answers with the default local box, which is the looser of the two.\n *\n * The contract mismatch that remains, recorded in the kernel doc: a screen\n * rectangle does not name a 3D pose without a depth, so `remapBounds` and\n * `fromBounds` have no honest answer.\n */\nexport function createPoseDescriptor<TData, TLayer extends string>(\n  world: World3d<TData, TLayer>,\n): PoseDescriptor<Pose3, Node3d<TData, TLayer>> {\n  const up = world.up ?? DEFAULT_UP;\n  const upAxis = up[1] !== 0 ? 1 : up[0] !== 0 ? 0 : 2;\n  const specialized = new WeakMap<object, PoseDescriptor<Pose3, Node3d<TData, TLayer>>>();\n\n  function build(worldBox: (pose: Pose3) => Aabb): PoseDescriptor<Pose3, Node3d<TData, TLayer>> {\n    const boundsOf = (pose: Pose3) => {\n      const vp = world.viewport();\n      return projectAabbToScreen(worldBox(pose), viewProjectionOf(vp), rectOf(vp));\n    };\n\n    const descriptor: PoseDescriptor<Pose3, Node3d<TData, TLayer>> = {\n      forNode(node) {\n        let d = specialized.get(node);\n        if (!d) {\n          // The pose arriving here is often an in-flight override rather than\n          // `node.pose`, so the consumer is asked about that pose on this node\n          // rather than about the node as committed.\n          d = build((pose) => boundsOfNode(world, { ...node, pose }));\n          specialized.set(node, d);\n        }\n        return d;\n      },\n\n      getBounds(pose) {\n        return boundsOf(pose) ?? { x: 0, y: 0, width: 0, height: 0 };\n      },\n\n      remapBounds() {\n        throw new Error(\n          'kernel3d: remapBounds has no 3D answer — a screen rectangle does not name a pose without a depth.',\n        );\n      },\n\n      fromBounds() {\n        throw new Error(\n          'kernel3d: fromBounds has no 3D answer — a screen rectangle does not name a pose without a depth.',\n        );\n      },\n\n      /**\n       * Screen-space deltas resolve against the plane the node already sits on,\n       * so the two numbers the kit passes are enough: the camera that turns\n       * them into a world position is the one this dep closed over.\n       */\n      translate(pose, dx, dy) {\n        const vp = world.viewport();\n        const box = boundsOf(pose);\n        if (!box) return pose;\n        const from = { x: box.x + box.width / 2, y: box.y + box.height / 2 };\n        const to = { x: from.x + dx, y: from.y + dy };\n        const offset = pose.position[upAxis];\n\n        const ray = rayAt(vp, to);\n        const t = intersectRayPlane(ray, up, offset);\n        if (t === null) return pose;\n\n        const anchorRay = rayAt(vp, from);\n        const anchorT = intersectRayPlane(anchorRay, up, offset);\n        if (anchorT === null) return pose;\n\n        const delta = sub(pointOnRay(ray, t), pointOnRay(anchorRay, anchorT));\n        const position: [number, number, number] = [\n          pose.position[0] + delta[0],\n          pose.position[1] + delta[1],\n          pose.position[2] + delta[2],\n        ];\n        position[upAxis] = pose.position[upAxis];\n        return { ...pose, position };\n      },\n\n      intersectsRect(pose, rect) {\n        const box = boundsOf(pose);\n        return box ? overlaps(box, rect) : false;\n      },\n\n      supportsRotation() {\n        return false;\n      },\n    };\n\n    return descriptor;\n  }\n\n  return build((pose) => aabbOfPose(pose));\n}\n","/**\n * What a host paints for a gesture that proposes chrome rather than a pose.\n *\n * A marquee sweep and a box-drag both publish an `OngoingOverlay`, which used\n * to reach paint only through core's own 2D layer. `resolveOverlays` hands back\n * world geometry with no renderer in it, so the same call `<SceneCanvas>` makes\n * serves a consumer-owned 3D renderer.\n *\n * A 3D host's `clientToWorld` is identity, so an overlay's world bounds are the\n * client rect the deps already work in, and the pane origin comes off exactly\n * once. Only the rectangular variants resolve here: a lasso, a pencil and a run\n * of points are paths, and a path is geometry this cannot flatten to a box.\n */\n\nimport { resolveOverlays, type OngoingHandle } from '@weasel-js/core';\nimport type { ChromeBox } from './screen';\n\n/** Gesture chrome, in CSS pixels relative to the pane's top-left. */\nexport function collectOverlayBoxes(\n  handles: Iterable<OngoingHandle>,\n  origin: { x: number; y: number },\n): ChromeBox[] {\n  const overlays = [];\n  for (const handle of handles) {\n    const ov = handle.overlay?.();\n    if (ov) overlays.push(ov);\n  }\n\n  const boxes: ChromeBox[] = [];\n  for (const resolved of resolveOverlays(overlays)) {\n    if (resolved.kind !== 'marquee' && resolved.kind !== 'insertPreview') continue;\n    const { x, y, width, height } = resolved.bounds;\n    boxes.push({ x: x - origin.x, y: y - origin.y, width, height, tint: 'gesture' });\n  }\n  return boxes;\n}\n","/**\n * Camera tools and their actions.\n *\n * Shape tools transfer from the kit untouched — a 3D host mounts core's own\n * `useSelectTool` and a rectangle-style insert binding and neither notices the\n * dimension. Only the viewport tools are written here, which is the one\n * exception the kernel doc predicted: `useHandTool` routes to\n * `viewport.dragPan`, and that wants the 2D `view`.\n */\n\nimport { defineTool, type Action, type Tool } from '@weasel-js/core';\nimport { dollyBy, orbitBy, type Camera3d } from './camera';\nimport type { Camera3dDep } from './cameraDep';\n\n/** Radians per CSS pixel of drag. A full pane width is a bit over half a turn. */\nconst ORBIT_RATE = 0.006;\nconst DOLLY_RATE = 0.0015;\n\nfunction cameraDep(deps: unknown): Camera3dDep | undefined {\n  return (deps as { camera3d?: Camera3dDep }).camera3d;\n}\n\nexport const orbitAction: Action = {\n  id: 'camera.orbit',\n  label: 'Orbit',\n  requires: ['camera3d'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx) {\n      const dep = cameraDep(ctx.deps);\n      const origin: Camera3d | undefined = dep?.get();\n      return {\n        kind: 'orbit',\n        onMove(move) {\n          if (!dep || !origin) return;\n          // `drag.delta` runs from the drag origin, not the previous move, so\n          // this composes against the camera as it was when the drag began.\n          const delta = move.drag?.screenDelta ?? move.drag?.delta;\n          if (!delta) return;\n          dep.set(orbitBy(origin, -delta.x * ORBIT_RATE, delta.y * ORBIT_RATE));\n        },\n      };\n    },\n  },\n};\n\nexport const dollyAction: Action = {\n  id: 'camera.dolly',\n  label: 'Dolly',\n  group: 'viewport',\n  // Wheel, in any tool — the dispatcher merges the event's deltas into params.\n  defaultBinding: [{ spec: { kind: 'wheel' }, opts: {} }],\n  requires: ['camera3d'],\n  invoker: {\n    timing: 'immediate',\n    run(deps, params) {\n      const dep = cameraDep(deps);\n      if (!dep) return;\n      const amount = typeof params?.deltaY === 'number' ? params.deltaY : 0;\n      dep.set(dollyBy(dep.get(), Math.exp(amount * DOLLY_RATE)));\n    },\n  },\n};\n\nexport function useOrbitTool(): Tool<null> {\n  return defineTool<null>({\n    id: 'orbit',\n    hookName: 'useOrbitTool',\n    cursor: 'grab',\n    presentation: { label: 'Orbit', group: 'viewport' },\n    bindings: [{ spec: { kind: 'drag' }, actionId: 'camera.orbit' }],\n  });\n}\n"]}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@weasel-js/kernel3d",
+  "version": "1.4.4",
+  "description": "3D kernel for weasel: poses, orbit camera, ray picking and screen-projected chrome geometry over core's scene graph and dispatcher. Hosts a renderer rather than owning one.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "author": "orochi235",
+  "homepage": "https://orochi235.github.io/weasel/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orochi235/weasel.git",
+    "directory": "packages/kernel3d"
+  },
+  "bugs": {
+    "url": "https://github.com/orochi235/weasel/issues"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@weasel-js/geom": "1.4.4"
+  },
+  "peerDependencies": {
+    "@weasel-js/core": "1.4.4"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}