@pascal-app/nodes 0.1.1

package/dist/solar-panel/renderer.js

@@ -0,0 +1,162 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, getRoofOuterSurfaceFrameAtPoint, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { MeshStandardNodeMaterial } from 'three/webgpu';
+import { surfaceQuatFromNormal } from '../shared/roof-surface';
+import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip';
+import { buildSolarPanelGeometry, getDefaultPanelMaterial } from './geometry';
+// Module-scope scratch vectors and quaternions for composing the panel's
+// local orientation each render — surfaceQuat · Y(rotation) · X(tilt).
+// Reused so we don't allocate four objects per frame.
+const yAxis = new THREE.Vector3(0, 1, 0);
+const xAxis = new THREE.Vector3(1, 0, 0);
+const panelYawQuat = new THREE.Quaternion();
+const panelTiltQuat = new THREE.Quaternion();
+// MeshStandardNodeMaterial: WebGPU-native so it integrates correctly with
+// the MRT pass (normal + roughness attachments). The legacy WebGL
+// MeshStandardMaterial triggers "Color target has no corresponding fragment
+// stage output / writeMask not zero" when the renderer switches pipelines
+// during a segment-reparent re-render.
+const defaultFrameMaterial = new MeshStandardNodeMaterial({
+    color: new THREE.Color(0.6, 0.6, 0.65),
+    roughness: 0.4,
+    metalness: 0.8,
+});
+/**
+ * Solar panel renderer. The panel's Y and surface tilt are derived
+ * live from the parent roof-segment's finished (deck + shingle) surface
+ * on every render via `getRoofOuterSurfaceFrameAtPoint` — the same
+ * authoritative helper skylights use. Deriving rather than reading the
+ * stored `position[1]`/`surfaceNormal` snapshot is what lets the panel
+ * re-seat and re-tilt automatically when the roof's wall height or
+ * pitch changes; a cached snapshot would leave it floating or buried.
+ *
+ * The segment's live overrides are merged too, so the panel tracks the
+ * surface continuously during a wall-height/pitch drag, not just after
+ * the value commits to the scene store.
+ *
+ * The surface orientation is applied as a quaternion on an inner
+ * group computed once per render (not per frame). This matches the
+ * static-transform pattern used by the other roof accessories and
+ * gives up the legacy `useFrame` quaternion smoothing — segment yaw
+ * changes still propagate immediately through the outer `rotation-y`
+ * binding.
+ */
+const SolarPanelRenderer = ({ node: storeNode }) => {
+    const ref = useRef(null);
+    useRegistry(storeNode.id, 'solar-panel', ref);
+    const handlers = useNodeEvents(storeNode, 'solar-panel');
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneTheme = useViewer((s) => s.sceneTheme);
+    // Merge live overrides written by slider drags so the mesh updates in
+    // real time before the value is committed to the scene store.
+    const overrides = useLiveNodeOverrides((s) => s.get(storeNode.id));
+    const node = overrides ? { ...storeNode, ...overrides } : storeNode;
+    const segment = useScene((state) => node.roofSegmentId
+        ? state.nodes[node.roofSegmentId]
+        : undefined);
+    // Merge the segment's live overrides (written by wall-height / pitch
+    // slider drags before they commit) so the panel re-seats and re-tilts
+    // in real time as the roof changes, mirroring the gutter's eave-snap.
+    const segmentOverrides = useLiveNodeOverrides((s) => node.roofSegmentId
+        ? s.get(node.roofSegmentId)
+        : undefined);
+    const effectiveSegment = segment
+        ? segmentOverrides
+            ? { ...segment, ...segmentOverrides }
+            : segment
+        : undefined;
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geometry = useMemo(() => buildSolarPanelGeometry(node), [
+        node.rows,
+        node.columns,
+        node.panelWidth,
+        node.panelHeight,
+        node.gapX,
+        node.gapY,
+        node.frameThickness,
+        node.frameDepth,
+        node.standoffHeight,
+    ]);
+    useEffect(() => () => geometry?.dispose(), [geometry]);
+    // Only the structural frame/mount surface is themed (→ 'roof'). The
+    // panel/cell face below is intentionally dark + product-specific and is
+    // left untouched in both texture modes.
+    const frameMaterial = useMemo(() => {
+        if (!textures || (!node.material && !node.materialPreset)) {
+            return createSurfaceRoleMaterial('roof', colorPreset, undefined, sceneTheme);
+        }
+        if (node.material)
+            return createMaterial(node.material, shading);
+        return createMaterialFromPresetRef(node.materialPreset, shading) ?? defaultFrameMaterial;
+    }, [textures, colorPreset, sceneTheme, shading, node.material, node.materialPreset]);
+    const panelMaterial = useMemo(() => {
+        if (node.panelMaterial)
+            return createMaterial(node.panelMaterial, shading);
+        return (createMaterialFromPresetRef(node.panelMaterialPreset, shading) ?? getDefaultPanelMaterial());
+    }, [shading, node.panelMaterial, node.panelMaterialPreset]);
+    // Finished-surface frame (deck + shingle top) at the panel's local
+    // X/Z, recomputed from the live segment each render — both the Y and
+    // the tilt normal flow from here, so a wall-height or pitch change
+    // re-seats and re-orients the panel automatically. `segmentOverrides`
+    // is in the deps so a live drag re-derives the frame mid-drag.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const surfaceFrame = useMemo(() => {
+        if (!effectiveSegment) {
+            return { point: new THREE.Vector3(), normal: new THREE.Vector3(0, 1, 0) };
+        }
+        return getRoofOuterSurfaceFrameAtPoint(effectiveSegment, node.position[0] ?? 0, node.position[2] ?? 0);
+    }, [segment, segmentOverrides, node.position[0], node.position[2]]);
+    const surfaceQuat = useMemo(() => surfaceQuatFromNormal(surfaceFrame.normal, new THREE.Quaternion()), [surfaceFrame.normal]);
+    // Map panel-local geometry into the host segment's local frame (where the
+    // trim cut prisms live). Recompose the same pose the inner mesh group is
+    // mounted with (position [x, surfaceY, z] + surfaceQuat·yaw·tilt) so the clip
+    // matches the rendered placement exactly. Computed before the early return so
+    // the hook order stays stable.
+    const localToSegment = useMemo(() => {
+        const surfaceY = surfaceFrame.point.y;
+        const tiltRad = node.mountingType === 'tilted' ? (node.tiltAngle * Math.PI) / 180 : 0;
+        const quat = new THREE.Quaternion()
+            .copy(surfaceQuat)
+            .multiply(new THREE.Quaternion().setFromAxisAngle(yAxis, node.rotation ?? 0))
+            .multiply(new THREE.Quaternion().setFromAxisAngle(xAxis, tiltRad));
+        return new THREE.Matrix4().compose(new THREE.Vector3(node.position[0] ?? 0, surfaceY, node.position[2] ?? 0), quat, new THREE.Vector3(1, 1, 1));
+    }, [
+        surfaceFrame.point.y,
+        surfaceQuat,
+        node.mountingType,
+        node.tiltAngle,
+        node.rotation,
+        node.position[0],
+        node.position[2],
+    ]);
+    const clippedGeometry = useSegmentTrimClippedGeometry(geometry, effectiveSegment, localToSegment);
+    if (!effectiveSegment || !geometry)
+        return null;
+    const surfaceY = surfaceFrame.point.y;
+    const tiltRad = node.mountingType === 'tilted' ? (node.tiltAngle * Math.PI) / 180 : 0;
+    // Compose surfaceQuat · Y(rotation) · X(tilt) into a single quaternion
+    // so the registered group below carries the panel's complete local pose
+    // (position + orientation) as its own *local* matrix. Registry handles
+    // (`portal: 'grandparent'`) read this Object3D's local position +
+    // quaternion to ride the panel; splitting the rotation across nested
+    // groups would leave the registered group with only the position and
+    // an identity quaternion, so the arrows would land on the segment-flat
+    // axes instead of on the tilted panel.
+    const composedQuat = new THREE.Quaternion()
+        .copy(surfaceQuat)
+        .multiply(panelYawQuat.setFromAxisAngle(yAxis, node.rotation ?? 0))
+        .multiply(panelTiltQuat.setFromAxisAngle(xAxis, tiltRad));
+    // Roof accessories are mounted under `<group name="roof-elements">`
+    // in the roof renderer — that group has NO transform, so the segment
+    // frame is NOT inherited from the React tree. Apply segment.position
+    // and segment.rotation here, then the panel's segment-local offset +
+    // composed orientation on a single registered group.
+    return (_jsx("group", { position: effectiveSegment.position, "rotation-y": effectiveSegment.rotation, children: _jsx("group", { position: [node.position[0] ?? 0, surfaceY, node.position[2] ?? 0], quaternion: composedQuat, ref: ref, visible: node.visible, children: _jsx("mesh", { castShadow: true, geometry: clippedGeometry ?? geometry, material: [frameMaterial, panelMaterial], name: "solar-panel-surface", receiveShadow: true, ...handlers }) }) }));
+};
+export default SolarPanelRenderer;

package/dist/solar-panel/schema.d.ts

@@ -0,0 +1,2 @@
+export { SolarPanelNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/solar-panel/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/solar-panel/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/solar-panel/schema.js

@@ -0,0 +1 @@
+export { SolarPanelNode } from '@pascal-app/core';

package/dist/solar-panel/tool.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Solar panel placement tool. The preview shows the array at the
+ * cursor with the analytical roof-surface tilt applied (no raycast in
+ * the placement preview — uses `getAnalyticalNormal` derived from the
+ * segment's roof type + dimensions). On commit, snaps the position's
+ * Y to the segment's surface height and stores the analytical normal
+ * in the node so the renderer reproduces the same orientation.
+ */
+declare const SolarPanelTool: () => import("react").JSX.Element;
+export default SolarPanelTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/solar-panel/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/solar-panel/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,QAAA,MAAM,cAAc,mCAoInB,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/solar-panel/tool.js

@@ -0,0 +1,120 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, SolarPanelNode, sceneRegistry, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
+import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
+import { solarPanelDefinition } from './definition';
+import SolarPanelPreview from './preview';
+const worldPoint = new THREE.Vector3();
+/**
+ * Solar panel placement tool. The preview shows the array at the
+ * cursor with the analytical roof-surface tilt applied (no raycast in
+ * the placement preview — uses `getAnalyticalNormal` derived from the
+ * segment's roof type + dimensions). On commit, snaps the position's
+ * Y to the segment's surface height and stores the analytical normal
+ * in the node so the renderer reproduces the same orientation.
+ */
+const SolarPanelTool = () => {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const setSelection = useViewer((s) => s.setSelection);
+    const [previewPos, setPreviewPos] = useState(null);
+    const [previewYaw, setPreviewYaw] = useState(0);
+    const [previewSurfaceQuat, setPreviewSurfaceQuat] = useState(null);
+    const lastSnapRef = useRef(null);
+    // Compact 2×3 ghost (rows × columns) — small enough to read as a
+    // pointer, large enough to show the array's orientation/aspect.
+    // The committed panel still uses the full residential defaults (4×5).
+    const previewNode = useMemo(() => SolarPanelNode.parse({
+        ...solarPanelDefinition.defaults(),
+        name: 'Solar Panel',
+        position: [0, 0, 0],
+        rotation: 0,
+        rows: 2,
+        columns: 3,
+    }), []);
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        const worldToBuildingLocal = (wx, wy, wz) => {
+            const buildingObj = sceneRegistry.nodes.get(activeBuildingId);
+            if (!buildingObj)
+                return [wx, wy, wz];
+            worldPoint.set(wx, wy, wz);
+            buildingObj.worldToLocal(worldPoint);
+            return [worldPoint.x, worldPoint.y, worldPoint.z];
+        };
+        const updatePreview = (event) => {
+            const wx = event.position[0];
+            const wy = event.position[1];
+            const wz = event.position[2];
+            const sx = Math.round(wx * 20) / 20;
+            const sz = Math.round(wz * 20) / 20;
+            const prev = lastSnapRef.current;
+            if (event.nativeEvent?.shiftKey !== true && (!prev || prev[0] !== sx || prev[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapRef.current = [sx, sz];
+            }
+            const hit = resolveRoofSegmentHit(event.node, wx, wy, wz);
+            if (!hit)
+                return;
+            const normal = getAnalyticalNormal(hit.localX, hit.localZ, hit.segment);
+            setPreviewSurfaceQuat(surfaceQuatFromNormal(normal, new THREE.Quaternion()));
+            setPreviewYaw((event.node.rotation ?? 0) + (hit.segment.rotation ?? 0));
+            setPreviewPos(worldToBuildingLocal(wx, wy, wz));
+            publishRoofSurfacePlacementGuides({
+                roof: event.node,
+                segment: hit.segment,
+                center: [hit.localX, hit.localY, hit.localZ],
+                footprint: roofSurfaceFootprintFromNode(previewNode),
+            });
+            event.stopPropagation();
+        };
+        const onClick = (event) => {
+            const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return;
+            const state = useScene.getState();
+            // Use the raycast hit Y (segment-local) and analytical normal so the
+            // committed panel sits exactly where the ghost was rendered. The
+            // analytical `getSurfaceY` is the bare-rafter height — it ignores
+            // deck/shingle layers and sinks the panel into the roof, producing
+            // a visible jump between ghost and committed mesh.
+            const normal = getAnalyticalNormal(hit.localX, hit.localZ, hit.segment);
+            const panel = SolarPanelNode.parse({
+                ...solarPanelDefinition.defaults(),
+                name: 'Solar Panel',
+                roofSegmentId: hit.segment.id,
+                position: [hit.localX, hit.localY, hit.localZ],
+                rotation: 0,
+                surfaceNormal: [normal.x, normal.y, normal.z],
+            });
+            state.createNode(panel, hit.segment.id);
+            state.dirtyNodes.add(hit.segment.id);
+            setSelection({ selectedIds: [panel.id] });
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            event.stopPropagation();
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onClick);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onClick);
+            clearRoofSurfacePlacementGuides();
+        };
+    }, [activeBuildingId, setSelection, previewNode]);
+    return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(SolarPanelPreview, { node: previewNode, invalid: true }), onInvalidTarget: () => {
+                    setPreviewPos(null);
+                    setPreviewSurfaceQuat(null);
+                    clearRoofSurfacePlacementGuides();
+                } }), activeBuildingId && previewPos && previewSurfaceQuat && (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx("group", { quaternion: previewSurfaceQuat, children: _jsx(SolarPanelPreview, { node: previewNode }) }) }) }))] }));
+};
+export default SolarPanelTool;

package/dist/spawn/definition.d.ts

@@ -0,0 +1,4 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { SpawnNode } from './schema';
+export declare const spawnDefinition: NodeDefinition<typeof SpawnNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/spawn/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAKpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0CpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAsE5D,CAAA"}

package/dist/spawn/definition.js

@@ -0,0 +1,107 @@
+import { buildSpawnFloorplan } from './floorplan';
+import { spawnRotateAffordance } from './floorplan-affordances';
+import { spawnFloorplanMoveTarget } from './floorplan-move';
+import { spawnParametrics } from './parametrics';
+import { SpawnNode } from './schema';
+const SPAWN_FOOTPRINT = 0.6;
+const SPAWN_HANDLE_HEIGHT = 0.46;
+const MOVE_FRONT_OFFSET = 0.35;
+const ROTATE_CORNER_OFFSET = 0.32;
+const ROTATE_RING_OFFSET = 0.04;
+function spawnRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: () => [
+                SPAWN_FOOTPRINT / 2,
+                SPAWN_HANDLE_HEIGHT,
+                SPAWN_FOOTPRINT / 2 + ROTATE_CORNER_OFFSET,
+            ],
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: () => Math.hypot(SPAWN_FOOTPRINT / 2, SPAWN_FOOTPRINT / 2) + ROTATE_RING_OFFSET,
+            y: () => SPAWN_HANDLE_HEIGHT,
+        },
+    };
+}
+function spawnMoveHandle() {
+    return {
+        kind: 'translate',
+        placement: {
+            // Low to the floor at the front edge (matches the item move grip).
+            position: () => [0, 0.02, SPAWN_FOOTPRINT / 2 + MOVE_FRONT_OFFSET],
+        },
+        apply: (_n, pos) => ({ position: [pos[0], pos[1], pos[2]] }),
+        snapExtents: () => [SPAWN_FOOTPRINT, SPAWN_FOOTPRINT],
+    };
+}
+export const spawnDefinition = {
+    kind: 'spawn',
+    snapProfile: 'item',
+    schemaVersion: 1,
+    schema: SpawnNode,
+    category: 'site',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+    }),
+    capabilities: {
+        movable: { axes: ['x', 'z'], gridSnap: true },
+        rotatable: {
+            axes: ['y'],
+            snapAngles: [0, Math.PI / 4, Math.PI / 2, (3 * Math.PI) / 4, Math.PI],
+        },
+        duplicable: false, // singleton per level
+        deletable: true,
+        selectable: { hitVolume: 'bbox' },
+        // Spawn is a singleton anchor — no meaning as a reusable preset.
+        presettable: false,
+        // Slab elevation lift via the generic `<FloorElevationSystem>`. The
+        // spawn marker is a 1.8m-tall figure with a ~0.6m ring footprint.
+        floorPlaced: {
+            footprint: () => ({ dimensions: [0.6, 1.8, 0.6], rotation: [0, 0, 0] }),
+        },
+    },
+    parametrics: spawnParametrics,
+    handles: [spawnRotateHandle(), spawnMoveHandle()],
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    // Stage C migration: floor-plan rendering via def.floorplan.
+    // floorplan-panel.tsx's `floorplanSpawnEntries` short-circuits to []
+    // when `nodeRegistry.has('spawn')`, so this builder is the single
+    // path. FloorplanRegistryLayer renders + handles click-to-select;
+    // FloorplanRegistryActionMenu handles move / duplicate (disabled) /
+    // delete. Legacy spawn click handlers in FloorplanNodeLayer become
+    // dead code once Phase 6 cleanup removes the [] entries path.
+    floorplan: buildSpawnFloorplan,
+    floorplanMoveTarget: spawnFloorplanMoveTarget,
+    floorplanAffordances: {
+        'spawn-rotate': spawnRotateAffordance,
+    },
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Left click', label: 'Place spawn point' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Spawn Point',
+        description: 'Player or camera origin within a level. One per level.',
+        icon: { kind: 'url', src: '/icons/spawn-point.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 90, // bottom of structure list — matches legacy palette order
+    },
+    mcp: {
+        description: 'A singleton spawn point marker placed inside a level.',
+    },
+};

package/dist/spawn/floorplan-affordances.d.ts

@@ -0,0 +1,3 @@
+import { type FloorplanAffordance, type SpawnNode } from '@pascal-app/core';
+export declare const spawnRotateAffordance: FloorplanAffordance<SpawnNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/spawn/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/spawn/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAGzB,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CA6BhE,CAAA"}

package/dist/spawn/floorplan-affordances.js

@@ -0,0 +1,31 @@
+import { useScene, } from '@pascal-app/core';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+export const spawnRotateAffordance = {
+    start({ node, initialPlanPoint }) {
+        const spawnId = node.id;
+        const initialRotation = node.rotation ?? 0;
+        const cx = node.position[0];
+        const cz = node.position[2];
+        const initialAngle = Math.atan2(initialPlanPoint[1] - cz, initialPlanPoint[0] - cx);
+        let lastRotation = initialRotation;
+        return {
+            affectedIds: [spawnId],
+            apply({ planPoint, modifiers }) {
+                const delta = rotateAffordanceDelta({
+                    center: [cx, cz],
+                    initialAngle,
+                    planPoint,
+                    free: modifiers.shiftKey,
+                });
+                lastRotation = initialRotation - delta;
+                useScene.getState().updateNode(spawnId, { rotation: lastRotation });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(spawnId, { rotation: lastRotation });
+            },
+        };
+    },
+};

package/dist/spawn/floorplan-move.d.ts

@@ -0,0 +1,3 @@
+import { type FloorplanMoveTarget, type SpawnNode } from '@pascal-app/core';
+export declare const spawnFloorplanMoveTarget: FloorplanMoveTarget<SpawnNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

package/dist/spawn/floorplan-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/spawn/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAExB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAGzB,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CA4BnE,CAAA"}

package/dist/spawn/floorplan-move.js

@@ -0,0 +1,31 @@
+import { snapScalar, useScene, } from '@pascal-app/core';
+import { getSegmentGridStep } from '@pascal-app/editor';
+export const spawnFloorplanMoveTarget = ({ node }) => {
+    const spawnId = node.id;
+    const startY = node.position[1];
+    const originalPosition = [...node.position];
+    let lastPosition = null;
+    const session = {
+        affectedIds: [spawnId],
+        apply({ planPoint, modifiers }) {
+            const step = getSegmentGridStep();
+            const snap = (value) => (modifiers.shiftKey ? value : snapScalar(value, step));
+            const next = [snap(planPoint[0]), startY, snap(planPoint[1])];
+            if (lastPosition && lastPosition[0] === next[0] && lastPosition[2] === next[2])
+                return;
+            lastPosition = next;
+            useScene.getState().updateNodes([{ id: spawnId, data: { position: next } }]);
+        },
+        canCommit() {
+            if (!lastPosition)
+                return false;
+            return lastPosition[0] !== originalPosition[0] || lastPosition[2] !== originalPosition[2];
+        },
+        commit() {
+            if (!lastPosition)
+                return;
+            useScene.getState().updateNodes([{ id: spawnId, data: { position: lastPosition } }]);
+        },
+    };
+    return session;
+};

package/dist/spawn/floorplan.d.ts

@@ -0,0 +1,14 @@
+import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { SpawnNode } from './schema';
+/**
+ * 2D floor-plan marker for a spawn point. Uses the same footprint icon
+ * as the walkthrough-mode control and rotates it toward the spawn's
+ * first-person starting view.
+ *
+ * Color matches the 3D renderer's indigo spawn material so the user
+ * sees the same visual identity in both views.
+ *
+ * Coordinates are level-local meters; rotation is radians.
+ */
+export declare function buildSpawnFloorplan(node: SpawnNode, ctx: GeometryContext): FloorplanGeometry;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/spawn/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/spawn/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAkB,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAC1F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAsCzC;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,CAwF5F"}

package/dist/spawn/floorplan.js

@@ -0,0 +1,135 @@
+const SPAWN_COLOR = '#818cf8';
+const SPAWN_MARKER_HIT_RADIUS = 0.52;
+const FOOTPRINT_ICON_SCALE = 0.045;
+const FOOTPRINT_ICON_CENTER = 12;
+const ROTATE_ARROW_CORNER_OFFSET = 0.22;
+const iconPoint = (x, y) => `${formatIconCoord(x - FOOTPRINT_ICON_CENTER)} ${formatIconCoord(y - FOOTPRINT_ICON_CENTER)}`;
+const iconY = (y) => formatIconCoord(y - FOOTPRINT_ICON_CENTER);
+const iconX = (x) => formatIconCoord(x - FOOTPRINT_ICON_CENTER);
+const iconArcRadius = formatIconCoord(2);
+const FOOTPRINT_LEFT_PATH = [
+    `M ${iconPoint(4, 16)}`,
+    `V ${iconY(13.62)}`,
+    `C ${iconPoint(4, 11.5)} ${iconPoint(2.97, 10.5)} ${iconPoint(3, 8)}`,
+    `C ${iconPoint(3.03, 5.28)} ${iconPoint(4.49, 2)} ${iconPoint(7.5, 2)}`,
+    `C ${iconPoint(9.37, 2)} ${iconPoint(10, 3.8)} ${iconPoint(10, 5.5)}`,
+    `C ${iconPoint(10, 8.61)} ${iconPoint(8, 11.16)} ${iconPoint(8, 14.18)}`,
+    `V ${iconY(16)}`,
+    `A ${iconArcRadius} ${iconArcRadius} 0 1 1 ${iconPoint(4, 16)}`,
+    'Z',
+].join(' ');
+const FOOTPRINT_RIGHT_PATH = [
+    `M ${iconPoint(20, 20)}`,
+    `V ${iconY(17.62)}`,
+    `C ${iconPoint(20, 15.5)} ${iconPoint(21.03, 14.5)} ${iconPoint(21, 12)}`,
+    `C ${iconPoint(20.97, 9.28)} ${iconPoint(19.51, 6)} ${iconPoint(16.5, 6)}`,
+    `C ${iconPoint(14.63, 6)} ${iconPoint(14, 7.8)} ${iconPoint(14, 9.5)}`,
+    `C ${iconPoint(14, 12.61)} ${iconPoint(16, 15.16)} ${iconPoint(16, 18.18)}`,
+    `V ${iconY(20)}`,
+    `A ${iconArcRadius} ${iconArcRadius} 0 1 0 ${iconPoint(20, 20)}`,
+    'Z',
+].join(' ');
+/**
+ * 2D floor-plan marker for a spawn point. Uses the same footprint icon
+ * as the walkthrough-mode control and rotates it toward the spawn's
+ * first-person starting view.
+ *
+ * Color matches the 3D renderer's indigo spawn material so the user
+ * sees the same visual identity in both views.
+ *
+ * Coordinates are level-local meters; rotation is radians.
+ */
+export function buildSpawnFloorplan(node, ctx) {
+    const [px, , pz] = node.position;
+    const ry = node.rotation;
+    const planRotation = -ry;
+    const isSelected = ctx.viewState?.selected ?? false;
+    const children = [
+        {
+            kind: 'group',
+            transform: { translate: [px, pz], rotate: planRotation },
+            children: [
+                {
+                    kind: 'circle',
+                    cx: 0,
+                    cy: 0,
+                    r: SPAWN_MARKER_HIT_RADIUS,
+                    fill: 'transparent',
+                    pointerEvents: 'all',
+                },
+                {
+                    kind: 'path',
+                    d: FOOTPRINT_LEFT_PATH,
+                    stroke: SPAWN_COLOR,
+                    strokeWidth: 2,
+                    vectorEffect: 'non-scaling-stroke',
+                    strokeLinecap: 'round',
+                    strokeLinejoin: 'round',
+                    fill: 'none',
+                },
+                {
+                    kind: 'path',
+                    d: FOOTPRINT_RIGHT_PATH,
+                    stroke: SPAWN_COLOR,
+                    strokeWidth: 2,
+                    vectorEffect: 'non-scaling-stroke',
+                    strokeLinecap: 'round',
+                    strokeLinejoin: 'round',
+                    fill: 'none',
+                },
+                {
+                    kind: 'line',
+                    x1: iconX(16),
+                    y1: iconY(17),
+                    x2: iconX(20),
+                    y2: iconY(17),
+                    stroke: SPAWN_COLOR,
+                    strokeWidth: 2,
+                    vectorEffect: 'non-scaling-stroke',
+                    strokeLinecap: 'round',
+                },
+                {
+                    kind: 'line',
+                    x1: iconX(4),
+                    y1: iconY(13),
+                    x2: iconX(8),
+                    y2: iconY(13),
+                    stroke: SPAWN_COLOR,
+                    strokeWidth: 2,
+                    vectorEffect: 'non-scaling-stroke',
+                    strokeLinecap: 'round',
+                },
+            ],
+        },
+    ];
+    if (isSelected) {
+        children.push({
+            kind: 'move-handle',
+            point: [px, pz],
+        });
+        const cornerLocalX = 0.34 + ROTATE_ARROW_CORNER_OFFSET;
+        const cornerLocalZ = 0.34 + ROTATE_ARROW_CORNER_OFFSET;
+        const [cornerX, cornerZ] = rotatePlanVector(cornerLocalX, cornerLocalZ, planRotation);
+        const [radialX, radialZ] = rotatePlanVector(1, 1, planRotation);
+        children.push({
+            kind: 'rotate-arrow',
+            point: [px + cornerX, pz + cornerZ],
+            angle: Math.atan2(radialZ, radialX),
+            affordance: 'spawn-rotate',
+            pivot: [px, pz],
+        });
+    }
+    return {
+        kind: 'group',
+        children,
+    };
+}
+function rotatePlanVector(x, y, rotation) {
+    const c = Math.cos(rotation);
+    const s = Math.sin(rotation);
+    return [x * c - y * s, x * s + y * c];
+}
+function formatIconCoord(value) {
+    const scaled = value * FOOTPRINT_ICON_SCALE;
+    return Number(scaled.toFixed(4));
+}