@pascal-app/core 0.8.0 → 0.9.2

package/dist/registry/__bench__/relations-resolver.bench.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Bench harness for the relations cascade resolver.
+ *
+ * Phase 1 risk gate: at 5000 nodes the resolver step must stay under
+ * 2ms p95 per `cascadeDirty` invocation. Above that, the registry-driven
+ * dispatch will tank framerate during a corner drag in Phase 3.
+ *
+ * Run via:
+ *   bun run packages/core/src/registry/__bench__/relations-resolver.bench.ts
+ *
+ * Output: JSON to stdout with { p50, p95, p99, mean, max, n } in milliseconds.
+ * Doubles as a regression gate — wire into CI when we have a baseline.
+ */
+export {};
+//# sourceMappingURL=relations-resolver.bench.d.ts.map

package/dist/registry/__bench__/relations-resolver.bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations-resolver.bench.d.ts","sourceRoot":"","sources":["../../../src/registry/__bench__/relations-resolver.bench.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/dist/registry/__bench__/relations-resolver.bench.js

@@ -0,0 +1,170 @@
+/**
+ * Bench harness for the relations cascade resolver.
+ *
+ * Phase 1 risk gate: at 5000 nodes the resolver step must stay under
+ * 2ms p95 per `cascadeDirty` invocation. Above that, the registry-driven
+ * dispatch will tank framerate during a corner drag in Phase 3.
+ *
+ * Run via:
+ *   bun run packages/core/src/registry/__bench__/relations-resolver.bench.ts
+ *
+ * Output: JSON to stdout with { p50, p95, p99, mean, max, n } in milliseconds.
+ * Doubles as a regression gate — wire into CI when we have a baseline.
+ */
+import { z } from 'zod';
+import { nodeRegistry, registerNode } from '../registry';
+import { cascadeDirty } from '../relations-resolver';
+const ID = (s) => s;
+function makeDef(kind, relations) {
+    return {
+        kind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(kind) }),
+        category: 'utility',
+        defaults: () => ({}),
+        capabilities: {},
+        relations,
+        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    };
+}
+/**
+ * Builds a 5000-node fixture: a 50×100 grid of walls (so 5000 walls).
+ * Each wall hosts up to 2 doors and is bordered by ~4 slabs (in a sparse
+ * spatial index). Designed to stress hosts + affectsSpatial cascade
+ * simultaneously.
+ *
+ * Returns:
+ * - 5000 wall nodes
+ * - 8000 door nodes (children of walls)
+ * - 200 slab nodes (sparse; ~25 walls per slab)
+ *
+ * Total: ~13,200 nodes. The cascade starts from one wall and should mark
+ * its children (doors) + its spatial neighbors (slabs) dirty.
+ */
+function buildFixture() {
+    const nodes = {};
+    const wallToSlabIds = new Map();
+    for (let row = 0; row < 50; row++) {
+        for (let col = 0; col < 100; col++) {
+            const wallId = ID(`wall_r${row}c${col}`);
+            const childIds = [];
+            for (let d = 0; d < 2; d++) {
+                const doorId = ID(`door_r${row}c${col}d${d}`);
+                childIds.push(doorId);
+                nodes[doorId] = {
+                    id: doorId,
+                    type: 'door',
+                    parentId: wallId,
+                    visible: true,
+                };
+            }
+            nodes[wallId] = {
+                id: wallId,
+                type: 'wall',
+                parentId: null,
+                visible: true,
+                children: childIds,
+            };
+            // Map this wall to its bordering slab (sparse: ~25 walls share a slab).
+            const slabRow = Math.floor(row / 5);
+            const slabCol = Math.floor(col / 5);
+            const slabId = ID(`slab_r${slabRow}c${slabCol}`);
+            const list = wallToSlabIds.get(wallId) ?? [];
+            list.push(slabId);
+            wallToSlabIds.set(wallId, list);
+        }
+    }
+    for (let row = 0; row < 10; row++) {
+        for (let col = 0; col < 20; col++) {
+            const slabId = ID(`slab_r${row}c${col}`);
+            nodes[slabId] = {
+                id: slabId,
+                type: 'slab',
+                parentId: null,
+                visible: true,
+            };
+        }
+    }
+    return { nodes, wallToSlabIds };
+}
+function makeScene(nodes) {
+    return {
+        get: ((nid) => nodes[nid]),
+        nodes: () => nodes,
+        update: () => { },
+        upsert: () => ID(''),
+        delete: () => { },
+        restore: () => { },
+        restoreAll: () => { },
+        markDirty: () => { },
+        pauseHistory: () => { },
+        resumeHistory: () => { },
+        getSubtree: () => null,
+        cloneNodesInto: () => null,
+    };
+}
+function percentile(values, p) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const idx = Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length));
+    return sorted[idx] ?? 0;
+}
+async function main() {
+    nodeRegistry._reset();
+    registerNode(makeDef('wall', { hosts: ['door'], affectsSpatial: ['slab'] }));
+    registerNode(makeDef('door'));
+    registerNode(makeDef('slab'));
+    const { nodes, wallToSlabIds } = buildFixture();
+    const scene = makeScene(nodes);
+    const spatialQuery = (node, kinds) => {
+        if (!kinds.includes('slab'))
+            return [];
+        return wallToSlabIds.get(node.id) ?? [];
+    };
+    const totalNodes = Object.keys(nodes).length;
+    const totalWalls = 50 * 100;
+    console.log(`[bench] fixture: ${totalNodes} nodes (${totalWalls} walls, 8000 doors, 200 slabs)`);
+    const iterations = 1000;
+    const samples = [];
+    // Warm-up — JIT, cache lines, etc.
+    for (let i = 0; i < 50; i++) {
+        cascadeDirty(ID(`wall_r${i % 50}c${i % 100}`), { scene, spatialQuery });
+    }
+    for (let i = 0; i < iterations; i++) {
+        const row = i % 50;
+        const col = i % 100;
+        const startId = ID(`wall_r${row}c${col}`);
+        const t0 = performance.now();
+        cascadeDirty(startId, { scene, spatialQuery });
+        const elapsed = performance.now() - t0;
+        samples.push(elapsed);
+    }
+    const mean = samples.reduce((acc, v) => acc + v, 0) / samples.length;
+    const max = Math.max(...samples);
+    const p50 = percentile(samples, 50);
+    const p95 = percentile(samples, 95);
+    const p99 = percentile(samples, 99);
+    const result = {
+        fixture: { totalNodes, walls: totalWalls, doors: 8000, slabs: 200 },
+        iterations,
+        p50_ms: Number(p50.toFixed(4)),
+        p95_ms: Number(p95.toFixed(4)),
+        p99_ms: Number(p99.toFixed(4)),
+        mean_ms: Number(mean.toFixed(4)),
+        max_ms: Number(max.toFixed(4)),
+    };
+    console.log(JSON.stringify(result, null, 2));
+    const target = 2.0;
+    if (p95 > target) {
+        console.error(`\n❌ p95 ${p95.toFixed(2)}ms exceeds Phase 1 gate of ${target}ms. ` +
+            `Phase 2 (column + shelf) can still proceed since their relations are empty, ` +
+            `but Phase 3 wall migration must add spatial-index-backed neighbor queries first.`);
+        process.exitCode = 1;
+    }
+    else {
+        console.log(`\n✅ p95 ${p95.toFixed(3)}ms within Phase 1 gate of ${target}ms`);
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/dist/registry/handles.d.ts

@@ -0,0 +1,394 @@
+import type { AnyNode, AnyNodeId } from '../schema/types';
+import type { SceneApi } from './types';
+/**
+ * Editor-facing verbs that handle descriptors can invoke.
+ *
+ * Parallel to {@link SceneApi} but exposes EDITOR state mutations (move
+ * tools, endpoint dragging, etc.) instead of scene-data writes. Descriptors
+ * receive a concrete implementation from the editor at drag time — `core`
+ * only carries the interface so node definitions can call into editor
+ * affordances without importing the editor package.
+ *
+ * Minimal verb set today; grow it as new descriptor variants land
+ * (engageCurve for wall/fence curving, etc.).
+ */
+export type EditorApi = {
+    /**
+     * Hand the node to its registered move tool (the same path the floating
+     * menu's Move icon uses). Implementations clear any in-progress endpoint
+     * or curving state so the move starts from a clean slate.
+     */
+    engageMove: (node: AnyNode) => void;
+    /**
+     * Like {@link engageMove}, but for a press-drag gizmo: the move commits on
+     * pointer-release instead of waiting for a click, so the on-canvas move cross
+     * behaves as press-drag-release while still showing the placement preview.
+     */
+    engageMoveDrag: (node: AnyNode) => void;
+    /**
+     * Engage endpoint drag for kinds that own start / end anchors (walls,
+     * fences). No-ops for kinds without endpoints.
+     */
+    engageEndpointMove: (node: AnyNode, endpoint: 'start' | 'end') => void;
+    /**
+     * Engage drag of a spline control point (`path[index]`). Used by spline
+     * fences to reshape their centerline. No-ops for kinds without a path.
+     */
+    engageControlPointMove: (node: AnyNode, index: number) => void;
+    /**
+     * Engage drag of a spline tangent handle (`path[index]`, which end). Used by
+     * spline fences to bend the curve through one control point. No-ops for kinds
+     * without tangents.
+     */
+    engageTangentMove: (node: AnyNode, index: number, side: 'in' | 'out') => void;
+};
+export type HandlePortal = 'self' | 'parent' | 'grandparent';
+export type HandleAxis = 'x' | 'y' | 'z';
+export type HandleAnchor = 'center' | 'min' | 'max';
+/** 3D position + rotation of the arrow in its portal target's local space. */
+export type HandlePlacement<N> = {
+    /**
+     * `sceneApi` is supplied so descriptors that depend on cross-node state
+     * (elevator height resolving level entries, future cross-kind handles)
+     * can compute placement against the live scene. Existing descriptors
+     * that only need `node` can ignore the second argument.
+     */
+    position: (node: N, sceneApi: SceneApi) => readonly [number, number, number];
+    /** Optional Y rotation (radians). Defaults to 0. */
+    rotationY?: (node: N, sceneApi: SceneApi) => number;
+};
+export type Cursor = 'ew-resize' | 'ns-resize' | 'move' | 'grab' | 'grabbing';
+/**
+ * Visual decoration shown alongside a handle while the user is hovering
+ * or dragging it. Today: a thin horizontal ring at a node-local radius —
+ * the curved-stair width / inner-radius arrows use this to trace the
+ * outer rim / inner pillar so the user sees what the drag affects.
+ *
+ * Pure data: the editor's arrow renderer reads it and mounts the visual.
+ */
+export type HandleDecoration<N> = {
+    kind: 'ring';
+    /** Node-local radius of the ring (XZ plane). */
+    radius: (node: N, sceneApi: SceneApi) => number;
+    /** Node-local Y of the ring. Defaults to 0. */
+    y?: (node: N) => number;
+    /** Node-local center of the ring. Defaults to the node origin. */
+    center?: (node: N, sceneApi: SceneApi) => readonly [number, number, number];
+};
+/**
+ * Linear resize along a single local axis. Covers width / depth / height
+ * arrows whose visible behaviour is "drag the +axis edge, the dimension
+ * grows."
+ *
+ * `anchor` controls which side stays fixed:
+ *   - 'center' : symmetric — both edges move ±delta (column width/depth).
+ *   - 'min'    : the -axis edge is fixed; drag the +axis edge by `delta`
+ *                grows the value by `delta` (column height with origin at
+ *                base; door height with bottom anchored).
+ *   - 'max'    : the +axis edge is fixed; drag the -axis edge.
+ *
+ * `apply(node, newValue)` returns the partial patch. Use it to write
+ * sibling fields too (e.g. door 'max' anchor re-centers `position[0]`).
+ */
+export type LinearResizeHandle<N> = {
+    kind: 'linear-resize';
+    /** Local axis. The arrow's chevron points along +axis. */
+    axis: HandleAxis;
+    anchor: HandleAnchor;
+    currentValue: (node: N) => number;
+    apply: (node: N, newValue: number, sceneApi: SceneApi) => Partial<N>;
+    /** Optional live-scene visibility gate for context-dependent arrows. */
+    visible?: (node: N, sceneApi: SceneApi) => boolean;
+    /**
+     * Optional committed-write hook. The generic handle renderer previews the
+     * selected node with the `apply` patch during drag; on release it normally
+     * writes that patch back to the same node. Composite nodes can override the
+     * final write here to fan the resize out to siblings / parents while keeping
+     * the handle UI generic.
+     */
+    commit?: (node: N, patch: Partial<N>, sceneApi: SceneApi) => void;
+    /**
+     * Optional per-tick hook fired while this handle is being dragged, with the
+     * live (in-progress, override-merged) node. A pure side-channel for transient
+     * feedback — doors/windows use it to publish proximity / sill guides for the
+     * edge being resized. The return value is ignored; the resize itself is driven
+     * by `apply`.
+     */
+    onDrag?: (node: N, sceneApi: SceneApi) => void;
+    /**
+     * Cross-node redirect. By default the drag's live override + the
+     * committed write both land on the SELECTED node. When this returns
+     * another node's id, the editor publishes the override to / commits on
+     * THAT node instead (and `apply` should return that node's patch).
+     * Used when a node's handle edits a value owned by a sibling — e.g. a
+     * downspout's side-move arrows slide its outlet, which lives on the
+     * host gutter (`gutter.outlets[].offset`). The selected node is still
+     * what `currentValue` / `apply` receive, so the descriptor can read
+     * the downspout to find its gutter + outlet.
+     */
+    overrideTarget?: (node: N, sceneApi: SceneApi) => AnyNodeId | undefined;
+    min?: number | ((node: N, sceneApi: SceneApi) => number);
+    max?: number | ((node: N, sceneApi: SceneApi) => number);
+    /** Snap the resized scalar to the editor's active grid step before apply. */
+    gridSnap?: boolean;
+    placement: HandlePlacement<N>;
+    /**
+     * Dimension this handle steers (e.g. `'height'`). When set, the editor
+     * publishes it to `activeHandleDrag.label` for the duration of the drag
+     * so out-of-band overlays (the floating dimension pill) can react, and
+     * the handle's own in-world value chip is suppressed to avoid showing
+     * the same number twice. Leave unset for handles that keep their inline
+     * chip and don't drive any external overlay.
+     */
+    measureLabel?: string;
+    /**
+     * Defaults to 'self' (arrow lives in the selected node's own mesh).
+     * 'parent' uses the parent mesh — used by doors/windows whose handles
+     * need to ride the wall's rotation.
+     */
+    portal?: HandlePortal;
+    cursor?: Cursor;
+    /** Optional visual guide shown while the arrow is hovered or dragging. */
+    decoration?: HandleDecoration<N>;
+    /**
+     * Visual override. Defaults to the standard chevron arrow.
+     *
+     * `'tracker'` swaps the chevron for a dashed vertical leader + a small
+     * cube at `placement.position`. The leader runs from the floor (local
+     * y=0) up to the cube; the cube is the drag target and reuses the same
+     * linear-resize drag pipeline as the chevron. Intended for vertical
+     * height handles where the dashed leader makes the "this is the wall
+     * top" relationship readable at a glance — mirrors the `corner-picker`
+     * shape on `tap-action` handles but with a draggable cube instead of a
+     * one-tap hex disc. Use with `axis: 'y'`; horizontal axes will render
+     * the leader vertically and look wrong.
+     */
+    shape?: 'arrow' | 'tracker';
+    /**
+     * Optional override for the bottom Y of the tracker leader. Defaults
+     * to 0 (floor of the rideObject's local frame). Use when the value
+     * being tracked spans a region that doesn't start at the floor — e.g.
+     * a chimney's body height runs from the roof deck up to the body top,
+     * so the leader should start at the deck plane and not climb through
+     * the roof shell below it. Only consulted when `shape === 'tracker'`.
+     */
+    trackerBaseY?: (node: N, sceneApi: SceneApi) => number;
+    /**
+     * Stand the chevron blade up into the node's facing plane instead of
+     * leaving it flat in the local XZ plane. For an `axis: 'x'` handle on a
+     * wall-mounted opening (door / window), the local XZ plane is horizontal,
+     * so the default blade is seen edge-on from the front — rotating it 90°
+     * about its pointing axis lays it in the wall face (local XY) so it reads
+     * face-on toward the camera. Chevron shape only; `axis: 'y'` handles are
+     * already stood up unconditionally so this is a no-op for them.
+     */
+    faceNormal?: boolean;
+    /**
+     * Gate this arrow behind a click-to-latch cube. When set, the arrow is
+     * hidden until the user clicks the {@link LatchHandle} cube declaring the
+     * same `group` name; clicking the cube again hides it. Lets a node keep a
+     * dense cluster (e.g. a dormer's window width/height arrows) collapsed
+     * behind a single grip until the user opts in. The latch state is local to
+     * the selection and resets when the node is deselected.
+     */
+    latchGroup?: string;
+};
+/**
+ * 1:1 outward growth — dragging the arrow outward by `delta` grows the
+ * value by `delta` (the visible edge follows the pointer). Use for radii
+ * and other fields where the conceptual model is "the +axis edge IS the
+ * thing being moved" rather than "the size IS being scaled."
+ */
+export type RadialResizeHandle<N> = {
+    kind: 'radial-resize';
+    axis: HandleAxis;
+    currentValue: (node: N) => number;
+    apply: (node: N, newValue: number, sceneApi: SceneApi) => Partial<N>;
+    min?: number | ((node: N, sceneApi: SceneApi) => number);
+    max?: number | ((node: N, sceneApi: SceneApi) => number);
+    placement: HandlePlacement<N>;
+    portal?: HandlePortal;
+    /** Optional visual guide shown while the arrow is hovered or dragging. */
+    decoration?: HandleDecoration<N>;
+};
+/**
+ * Curved / spiral stair sweep arrows. The renderer raycasts a horizontal
+ * plane through the arrow's Y and emits the angular delta (radians,
+ * signed, normalised to [-π, π]) around the node's local origin.
+ *
+ * Unlike the linear variants, `apply` receives the raw cursor delta
+ * (not a `newValue`) because sweep handles typically write multiple
+ * fields off the delta (`sweepAngle` AND `rotation` — re-orienting the
+ * arc so the opposite edge stays world-fixed). Descriptor-internal
+ * math handles the per-end sign and any clamping; the renderer stays
+ * out of it.
+ */
+export type ArcResizeHandle<N = any> = {
+    kind: 'arc-resize';
+    /**
+     * Marks the drag mode. Only 'angular' uses the polar plane renderer;
+     * 'radial' and 'vertical' degenerate to `linear-resize` (axis 'x' /
+     * 'y') so descriptors should prefer that for those cases.
+     */
+    axis: 'angular';
+    /** Optional metadata for descriptors that bundle two handles per kind. */
+    end?: 'start' | 'end';
+    apply: (initialNode: N, delta: number, sceneApi: SceneApi) => Partial<N>;
+    placement: HandlePlacement<N>;
+    portal?: HandlePortal;
+    /** Optional visual guide shown while the arrow is hovered or dragging. */
+    decoration?: HandleDecoration<N>;
+    /**
+     * Visual override. Defaults to the standard chevron (used by the
+     * stair-sweep extend handles). 'rotate' renders a two-headed curved
+     * arrow icon, intended for whole-node rotation handles.
+     */
+    shape?: 'chevron' | 'rotate';
+    /**
+     * Plane the angular drag is measured in:
+     *   - 'horizontal' (default): cursor bearing around +Y — whole-node yaw
+     *     (floor items, elevator, stair, roof-segment).
+     *   - 'node-normal': cursor bearing around the node's local +Z axis, in
+     *     the plane perpendicular to it — spins a wall-mounted item flat
+     *     against its wall. The descriptor's `apply` writes the roll
+     *     component (rotation[2]). The gizmo icon stands up into that plane.
+     */
+    rotationPlane?: 'horizontal' | 'node-normal';
+    /**
+     * Pivot point for the angular drag, in the rideObject's local space.
+     * The renderer measures cursor angle (atan2 on the drag plane) around
+     * this point — descriptors that write `rotation` should anchor it to
+     * the node's visual center. Defaults to the rideObject's own origin,
+     * which is correct for nodes whose mesh origin coincides with the
+     * field they're rotating (roof-segment, elevator). Use this when the
+     * node's pose is baked into its geometry (chimney) so the mesh origin
+     * sits at the parent frame's origin rather than the rotating shape's
+     * center.
+     */
+    rotationCenter?: (node: N, sceneApi: SceneApi) => readonly [number, number, number];
+};
+/**
+ * Wall / fence endpoint drag. Snapping and adjacency belong to the kind,
+ * so the descriptor declares the placement and hands the world-space
+ * pointer position back to `apply`. The kind can splice walls, snap to
+ * a grid, merge with a neighbour, etc., and returns the partial patch.
+ */
+export type EndpointMoveHandle<N> = {
+    kind: 'endpoint-move';
+    endpoint: 'start' | 'end';
+    placement: HandlePlacement<N>;
+    /** Called with the world-space hit on the ground plane. */
+    apply: (node: N, worldPoint: readonly [number, number, number], sceneApi: SceneApi) => Partial<N>;
+    portal?: HandlePortal;
+};
+/**
+ * Click-to-engage affordance. The descriptor doesn't drive a drag — its
+ * single job is to mount a click target at `placement` and dispatch a
+ * verb on the editor API when the user clicks. Used by wall side-move
+ * (engage move tool) and wall corner pickers (engage endpoint move).
+ *
+ * The renderer picks the visual from `shape`. Default `'arrow'` reuses
+ * the chevron shape every resize handle uses. `'corner-picker'` renders
+ * a dashed vertical leader + billboarded hex disc + ring, anchored at
+ * `placement.position` and extending up to `nodeHeight(node)`.
+ */
+export type TapActionHandle<N = any> = {
+    kind: 'tap-action';
+    placement: HandlePlacement<N>;
+    /**
+     * Dispatched on pointer-down. Use scene/editor APIs to read state +
+     * trigger the desired action.
+     */
+    onActivate: (node: N, scene: SceneApi, editor: EditorApi) => void;
+    /**
+     * Visual override; defaults to the standard chevron arrow. `'move-cross'`
+     * reuses the 4-way move cross — a tap-to-engage grip that hands the node to
+     * its move tool (via `onActivate`) instead of running the generic translate
+     * drag, so the move tool's own preview / ticker feedback shows up.
+     */
+    shape?: 'arrow' | 'corner-picker' | 'move-cross';
+    /**
+     * `shape: 'corner-picker'` only — render the disc and its outer ring as a
+     * circle instead of the default hexagon.
+     */
+    round?: boolean;
+    /**
+     * Required when `shape: 'corner-picker'` — controls the dashed leader's
+     * vertical extent. Pure callback so the descriptor doesn't need to
+     * import 3D libs.
+     */
+    nodeHeight?: (node: N) => number;
+    /**
+     * `shape: 'move-cross'` only — tilts the flat cross to lie in the right
+     * plane. `'horizontal'` (default) leaves it flat on the floor; `'node-normal'`
+     * stands it up against the node's facing plane (a wall face).
+     */
+    plane?: 'horizontal' | 'node-normal';
+    portal?: HandlePortal;
+    cursor?: Cursor;
+};
+/**
+ * Free ground-plane move. Drag the handle and the node slides across the
+ * horizontal plane at its base — the renderer raycasts that plane, converts
+ * the hit into the node's parent-local frame, and reports the new local XZ
+ * (optionally grid-snapped via `snapExtents`) to `apply`. Press-drag-release
+ * with the same live-override → commit-on-release flow as the resize / rotate
+ * handles. Rendered as a 4-way cross of double-headed arrows. Pure translation
+ * does not require geometry dirtying; renderers consume the live position
+ * override directly.
+ */
+export type TranslateHandle<N = any> = {
+    kind: 'translate';
+    placement: HandlePlacement<N>;
+    /**
+     * Plane the drag is constrained to (through the node origin):
+     *   - 'horizontal' (default): the ground plane (world-up normal) — slide
+     *     across the floor. The free axes are parent-local X / Z.
+     *   - 'node-normal': the plane perpendicular to the node's local +Z axis
+     *     (its facing direction) — slide across a wall face. The free axes are
+     *     parent-local X / Y; depth (Z) stays pinned to the surface.
+     */
+    plane?: 'horizontal' | 'node-normal';
+    /**
+     * `localPos` is the dragged-to position in the node's PARENT-local frame,
+     * with the two in-plane axes already grid-snapped (if `snapExtents` is set)
+     * and the off-plane axis pinned to its drag-start value. Return the patch
+     * that writes it to the node's position field.
+     */
+    apply: (initialNode: N, localPos: readonly [number, number, number], sceneApi: SceneApi) => Partial<N>;
+    /**
+     * Optional grid-snap footprint for the two in-plane axes, in order
+     * `[alongX, alongOther]` — `alongOther` is Z for the 'horizontal' plane and
+     * Y for 'node-normal'. Used to align the node's edges to the grid (rotation-
+     * aware: swap the pair at 90°). Omit / return null for free movement.
+     * `sceneApi` is supplied for composite nodes whose footprint depends on
+     * children, such as straight stairs.
+     */
+    snapExtents?: (node: N, sceneApi: SceneApi) => readonly [number, number] | null;
+    portal?: HandlePortal;
+};
+/**
+ * Click-to-latch cube. Renders a small persistent cube at `placement` that
+ * toggles the visibility of every handle tagged with the matching
+ * {@link LinearResizeHandle.latchGroup} `group`. Clicking the cube once shows
+ * the group's arrows; clicking again hides them. The latch state is local to
+ * the current selection and resets on deselect.
+ *
+ * Mirrors the duct-fitting selection cube but driven by descriptor data so any
+ * node can collapse a dense arrow cluster behind one grip — e.g. a dormer's
+ * window width/height arrows latch behind a cube at the window center.
+ */
+export type LatchHandle<N = any> = {
+    kind: 'latch';
+    /** The `latchGroup` name whose arrows this cube reveals / hides. */
+    group: string;
+    placement: HandlePlacement<N>;
+    portal?: HandlePortal;
+};
+export type HandleDescriptor<N = any> = LinearResizeHandle<N> | RadialResizeHandle<N> | ArcResizeHandle<N> | EndpointMoveHandle<N> | TapActionHandle<N> | TranslateHandle<N> | LatchHandle<N>;
+/**
+ * Static array, or a function for shape-dependent cases (column
+ * crossSection / supportStyle, stair-segment segmentType, etc.).
+ */
+export type HandleList<N> = HandleDescriptor<N>[] | ((node: N) => HandleDescriptor<N>[]);
+//# sourceMappingURL=handles.d.ts.map

package/dist/registry/handles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../../src/registry/handles.ts"],"names":[],"mappings":"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"}

package/dist/registry/handles.js

@@ -0,0 +1,24 @@
+// In-world resize / move arrow descriptors. Each `NodeDefinition` may
+// declare a `handles` list (or a `(node) => list` function for shape-
+// dependent affordances). The editor mounts a single generic component
+// that reads these descriptors and renders the arrows / drag logic — no
+// per-kind handles file needed.
+//
+// Pure data + small per-descriptor callbacks: no Three.js, React, or
+// editor imports here so this stays in core. The descriptors are
+// evaluated by the editor at drag time (`apply` etc.) so the callbacks
+// run in the editor's context — they see the live node and the scene
+// API but otherwise do not import 3D libraries.
+//
+// Layered intentionally:
+//   - axis-resize    : symmetric scaling around center (column W/D, height)
+//   - edge-resize    : anchored on one edge, the other follows the pointer
+//                      (door width: drag right edge, left edge stays)
+//   - vertical-resize: linear-resize specialised for world-Y (height arrow
+//                      anchored at bottom; window top-edge anchored at
+//                      bottom; window bottom-edge anchored at top)
+//   - radial-resize  : 1:1 outward growth of a radial field (column radius)
+//   - arc-resize     : curved/spiral stair sweep / inner-radius / rise
+//   - endpoint-move  : wall / fence endpoint drag (snapping is bespoke,
+//                      so it delegates to a kind-supplied callback)
+export {};

package/dist/registry/index.d.ts

@@ -0,0 +1,7 @@
+export type { ArcResizeHandle, Cursor, EditorApi, EndpointMoveHandle, HandleAnchor, HandleAxis, HandleDescriptor, HandleList, HandlePlacement, HandlePortal, LatchHandle, LinearResizeHandle, RadialResizeHandle, TapActionHandle, TranslateHandle, } from './handles';
+export { bakePolicyOf, discoverPlugins, extendPluginDiscovery, getHostRefFields, getNodePluginId, getSelectableKinds, hasRegistry3DMoveTool, isDrawnViaTool, isDrawnViaToolKind, isNodeKindEnabled, isPresettable, isPresettableKind, isRegistryMovable, isRegistrySelectable, kindsWithBakePolicy, kindsWithFloorplanScope, loadPlugin, nodeRegistry, type PluginDiscovery, registerNode, resolveFacingIndicator, setPluginDiscovery, } from './registry';
+export { type CascadeContext, type ChildQuery, cascadeDirty, collectDescendants, type SpatialQuery, } from './relations-resolver';
+export { createSceneApi, type SceneStoreLike } from './scene-api';
+export { type CloneNodesIntoOptions, type CloneNodesIntoResult, cloneNodesInto, collectSubtree, type Subtree, } from './subtree';
+export type { Affordance, AlignmentFootprint, AlignmentFootprintConfig, AnyNodeDefinition, AssetRef, BakePolicy, BakeReplaceRenderer, Capabilities, CapabilityCtx, CuttableConfig, DistributionRole, DragAction, DuplicableConfig, DuplicateSubtreeCloneArgs, DuplicateSubtreeCloneResult, EditorCtx, ExportAnimationContext, FloorPlacedConfig, FloorPlacedFootprint, FloorPlacedFootprintContext, FloorPlacedFootprintResolver, FloorPlacedFootprintsResolver, FloorplanAffordance, FloorplanAffordanceModifiers, FloorplanAffordancePoint, FloorplanAffordanceSession, FloorplanGeometry, FloorplanMoveTarget, FloorplanMoveTargetSession, FloorplanPalette, FloorplanPoint, FloorplanStyle, GeometryContext, HostableConfig, IconRef, Issue, KeyboardAction, KeyboardActions, LazyComponent, LiveTransformLike, McpOverrides, MeasurementContribution, MeasurementFeature, MeasurementFeatureBinding, MeasurementFeatureGeometry, MeasurementSnapKind, Modifiers, MovableConfig, MovableParentFrame, NodeCategory, NodeDefinition, NodePort, NodeQuickAction, NodeQuickActionIcon, NodeQuickActionProvider, NodeQuickActionResult, NodeRegistry, PaintCapability, PaintEffectiveMaterialArgs, PaintPatchArgs, PaintPreviewArgs, PaintResolveArgs, ParamAction, ParametricDescriptor, ParamField, ParamGroup, ParentFrameSnapMatch, Plugin, Presentation, QuickMeasurementMetric, QuickMeasurementQuantity, QuickMeasurementReport, Relations, RendererSource, RoofAccessoryConfig, RotatableConfig, ScalableConfig, SceneActionCapability, SceneApi, SelectableConfig, SlotDeclaration, SnapPointKind, SnapProfile, SnappableConfig, SnapServicesLike, SurfacePoint, SurfaceQuery, SurfaceRole, SurfacesConfig, SystemContribution, ToolHint, ToolHintChip, Vec2, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/registry/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,eAAe,EACf,MAAM,EACN,SAAS,EACT,kBAAkB,EAClB,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,YAAY,EACZ,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,eAAe,GAChB,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACvB,UAAU,EACV,YAAY,EACZ,KAAK,eAAe,EACpB,YAAY,EACZ,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,YAAY,EACZ,kBAAkB,EAClB,KAAK,YAAY,GAClB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAA;AACjE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,cAAc,EACd,cAAc,EACd,KAAK,OAAO,GACb,MAAM,WAAW,CAAA;AAClB,YAAY,EACV,UAAU,EACV,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EACjB,QAAQ,EACR,UAAU,EACV,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,gBAAgB,EAChB,yBAAyB,EACzB,2BAA2B,EAC3B,SAAS,EACT,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,EAC7B,mBAAmB,EACnB,4BAA4B,EAC5B,wBAAwB,EACxB,0BAA0B,EAC1B,iBAAiB,EACjB,mBAAmB,EACnB,0BAA0B,EAC1B,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,eAAe,EACf,cAAc,EACd,OAAO,EACP,KAAK,EACL,cAAc,EACd,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,EACvB,kBAAkB,EAClB,yBAAyB,EACzB,0BAA0B,EAC1B,mBAAmB,EACnB,SAAS,EACT,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,cAAc,EACd,QAAQ,EACR,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,YAAY,EACZ,eAAe,EACf,0BAA0B,EAC1B,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,oBAAoB,EACpB,UAAU,EACV,UAAU,EACV,oBAAoB,EACpB,MAAM,EACN,YAAY,EACZ,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,SAAS,EACT,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,QAAQ,EACR,YAAY,EACZ,IAAI,GACL,MAAM,SAAS,CAAA"}

package/dist/registry/index.js

@@ -0,0 +1,4 @@
+export { bakePolicyOf, discoverPlugins, extendPluginDiscovery, getHostRefFields, getNodePluginId, getSelectableKinds, hasRegistry3DMoveTool, isDrawnViaTool, isDrawnViaToolKind, isNodeKindEnabled, isPresettable, isPresettableKind, isRegistryMovable, isRegistrySelectable, kindsWithBakePolicy, kindsWithFloorplanScope, loadPlugin, nodeRegistry, registerNode, resolveFacingIndicator, setPluginDiscovery, } from './registry';
+export { cascadeDirty, collectDescendants, } from './relations-resolver';
+export { createSceneApi } from './scene-api';
+export { cloneNodesInto, collectSubtree, } from './subtree';