@pascal-app/core 0.7.0 → 0.9.1

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,321 @@
+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;
+};
+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) => number;
+    /** Node-local Y of the ring. Defaults to 0. */
+    y?: (node: N) => 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>;
+    /**
+     * 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;
+};
+/**
+ * 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';
+    /**
+     * 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;
+};
+export type HandleDescriptor<N = any> = LinearResizeHandle<N> | RadialResizeHandle<N> | ArcResizeHandle<N> | EndpointMoveHandle<N> | TapActionHandle<N> | TranslateHandle<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, LinearResizeHandle, RadialResizeHandle, TapActionHandle, TranslateHandle, } from './handles';
+export { discoverPlugins, getHostRefFields, getSelectableKinds, isDrawnViaTool, isDrawnViaToolKind, isPresettable, isPresettableKind, isRegistryMovable, isRegistrySelectable, kindsWithFloorplanScope, loadPlugin, nodeRegistry, type PluginDiscovery, registerNode, 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, Capabilities, CapabilityCtx, CuttableConfig, DragAction, EditorCtx, FloorPlacedConfig, FloorPlacedFootprint, FloorPlacedFootprintContext, FloorPlacedFootprintResolver, FloorPlacedFootprintsResolver, FloorplanAffordance, FloorplanAffordanceModifiers, FloorplanAffordancePoint, FloorplanAffordanceSession, FloorplanGeometry, FloorplanMoveTarget, FloorplanMoveTargetSession, FloorplanPalette, FloorplanPoint, FloorplanStyle, GeometryContext, HostableConfig, IconRef, Issue, KeyboardAction, KeyboardActions, LazyComponent, McpOverrides, Modifiers, MovableConfig, NodeCategory, NodeDefinition, NodeRegistry, PaintCapability, PaintEffectiveMaterialArgs, PaintPatchArgs, PaintPreviewArgs, PaintResolveArgs, ParamAction, ParametricDescriptor, ParamField, ParamGroup, Plugin, Presentation, Relations, RendererSource, RoofAccessoryConfig, RotatableConfig, ScalableConfig, SceneApi, SelectableConfig, SnapPointKind, SnappableConfig, SnapServicesLike, SurfacePoint, SurfaceQuery, SurfaceRole, SurfacesConfig, SystemContribution, ToolHint, 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,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,eAAe,GAChB,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,UAAU,EACV,YAAY,EACZ,KAAK,eAAe,EACpB,YAAY,EACZ,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,YAAY,EACZ,aAAa,EACb,cAAc,EACd,UAAU,EACV,SAAS,EACT,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,YAAY,EACZ,SAAS,EACT,aAAa,EACb,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,eAAe,EACf,0BAA0B,EAC1B,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,oBAAoB,EACpB,UAAU,EACV,UAAU,EACV,MAAM,EACN,YAAY,EACZ,SAAS,EACT,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,QAAQ,EACR,IAAI,GACL,MAAM,SAAS,CAAA"}

package/dist/registry/index.js

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

package/dist/registry/registry.d.ts

@@ -0,0 +1,93 @@
+import type { AnyNodeDefinition, NodeRegistry, Plugin } from './types';
+export declare const nodeRegistry: NodeRegistry & {
+    _register: (def: AnyNodeDefinition) => void;
+    _reset: () => void;
+};
+export declare function registerNode(def: AnyNodeDefinition): void;
+/**
+ * Returns the set of registered kinds whose definition declares the
+ * `selectable` capability. Callers that maintain hardcoded "selectable kinds"
+ * lists (SelectionManager, FloatingActionMenu) should concat this with their
+ * legacy entries instead of editing the hardcoded list per migration.
+ *
+ * Phase 6 deletes the hardcoded lists entirely and uses this function as the
+ * single source of truth. For now it's additive over the legacy lists so the
+ * existing kinds keep working unchanged.
+ */
+export declare function getSelectableKinds(): string[];
+/**
+ * Returns true when the kind is declared selectable in the registry. Use
+ * in expression chains like `if (node.type === 'wall' || isRegistrySelectable(node.type))`.
+ */
+export declare function isRegistrySelectable(kind: string): boolean;
+/**
+ * Kinds whose `def.floorplanScope` matches the requested scope. Used by
+ * `FloorplanRegistryLayer` to discover building-scoped kinds (e.g.
+ * elevator) without hardcoding kind names in the editor layer. `'level'`
+ * is the default, so `kindsWithFloorplanScope('level')` includes kinds
+ * that didn't set the field at all.
+ */
+export declare function kindsWithFloorplanScope(scope: 'level' | 'building'): string[];
+/**
+ * Returns true when the kind is movable from a 2D floor-plan handle —
+ * either via `capabilities.movable`, an explicit
+ * `def.floorplanMoveTarget`, or an `affordanceTools.move` 3D mover that
+ * the floating action menu can engage. Replaces the kind-name ternary
+ * chain in `floating-action-menu.tsx`.
+ */
+export declare function isRegistryMovable(kind: string): boolean;
+/**
+ * Whether the kind can be saved as a reusable preset. Default: an
+ * explicit `capabilities.presettable` boolean wins; otherwise the kind
+ * is presettable iff it declares `def.parametrics`. Read by host apps
+ * (community shell) to gate "save as preset" UI on a selection.
+ */
+export declare function isPresettable(def: AnyNodeDefinition): boolean;
+export declare function isPresettableKind(kind: string): boolean;
+/**
+ * Names of schema fields on `def` that are host references (`wallId`,
+ * `wallT`, etc.). Read by host apps at preset-save time to strip these
+ * from the stored payload — see `def.capabilities.hostRefFields` docs.
+ * Returns an empty array for kinds that don't declare any.
+ */
+export declare function getHostRefFields(def: AnyNodeDefinition): ReadonlyArray<string>;
+/**
+ * Whether instances of this kind are created by drawing with a build tool
+ * (tool id === node `type`) rather than dropping a finished instance. Read
+ * by host apps to route preset placement of such kinds through
+ * `setToolDefaults(type, params)` + `setTool(type)` — see
+ * `def.capabilities.drawTool` docs.
+ */
+export declare function isDrawnViaTool(def: AnyNodeDefinition): boolean;
+export declare function isDrawnViaToolKind(kind: string): boolean;
+export declare function loadPlugin(plugin: Plugin): Promise<void>;
+/**
+ * App-level plugin discovery hook. The bootstrap loads `builtinPlugin`
+ * unconditionally and then awaits this to pick up any extra plugins
+ * (third-party node packs, AI-authored bundles, user-installed kinds).
+ * Defaults to returning `[]` — apps that want external plugins call
+ * {@link setPluginDiscovery} before the bootstrap module runs.
+ *
+ * Kept async so a future loader can fetch over the network without
+ * changing the contract. See `wiki/editor-plugin-authoring.md` for the
+ * plugin author surface this enables.
+ */
+export type PluginDiscovery = () => Promise<Plugin[]>;
+/**
+ * Replace the plugin discovery implementation. Call once at app startup
+ * before {@link discoverPlugins} is invoked (bootstrap order matters).
+ *
+ * The contract is intentionally minimal — just "return a list of
+ * plugins to load." The loader can be a static `import.meta.glob`, a
+ * `fetch` against a registry endpoint, a worker IPC, etc. Each returned
+ * plugin still goes through {@link loadPlugin} so the same API-version
+ * gate + duplicate-kind protection applies.
+ */
+export declare function setPluginDiscovery(fn: PluginDiscovery): void;
+/**
+ * Run the active plugin discovery and return the discovered plugins.
+ * Bootstrap code is expected to call this after `loadPlugin(builtinPlugin)`
+ * and then `await loadPlugin(...)` each result in order.
+ */
+export declare function discoverPlugins(): Promise<Plugin[]>;
+//# sourceMappingURL=registry.d.ts.map