@pascal-app/nodes 0.1.1

package/dist/spawn/index.d.ts

@@ -0,0 +1,3 @@
+export { spawnDefinition } from './definition';
+export { SpawnNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spawn/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA"}

package/dist/spawn/index.js

@@ -0,0 +1,2 @@
+export { spawnDefinition } from './definition';
+export { SpawnNode } from './schema';

package/dist/spawn/panel.d.ts

@@ -0,0 +1,2 @@
+export default function SpawnPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/spawn/panel.tsx"],"names":[],"mappings":"AAgBA,MAAM,CAAC,OAAO,UAAU,UAAU,uCAwJjC"}

package/dist/spawn/panel.js

@@ -0,0 +1,71 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLiveTransforms, useScene } from '@pascal-app/core';
+import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Move, Trash2 } from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+export default function SpawnPanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const setSelection = useViewer((s) => s.setSelection);
+    const updateNode = useScene((s) => s.updateNode);
+    const deleteNode = useScene((s) => s.deleteNode);
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    const [draftRotation, setDraftRotation] = useState(null);
+    useEffect(() => {
+        if (!(node && node.type === 'spawn')) {
+            setDraftRotation(null);
+            return;
+        }
+        setDraftRotation(node.rotation);
+        useLiveTransforms.getState().clear(node.id);
+    }, [node?.id, node?.rotation, node?.type, node]);
+    const handleUpdate = useCallback((updates) => {
+        if (!(selectedId && node))
+            return;
+        updateNode(selectedId, updates);
+    }, [node, selectedId, updateNode]);
+    const handleRotationChange = useCallback((degrees) => {
+        if (!(node && selectedId))
+            return;
+        const nextRotation = (degrees * Math.PI) / 180;
+        setDraftRotation(nextRotation);
+        useLiveTransforms.getState().set(selectedId, {
+            position: [...node.position],
+            rotation: nextRotation,
+        });
+    }, [node, selectedId]);
+    const commitRotation = useCallback((degrees) => {
+        if (!(node && selectedId))
+            return;
+        const nextRotation = (degrees * Math.PI) / 180;
+        useLiveTransforms.getState().clear(selectedId);
+        setDraftRotation(nextRotation);
+        if (Math.abs(nextRotation - node.rotation) > 1e-6) {
+            updateNode(selectedId, { rotation: nextRotation });
+        }
+    }, [node, selectedId, updateNode]);
+    const handleClose = useCallback(() => {
+        setSelection({ selectedIds: [] });
+    }, [setSelection]);
+    const handleMove = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        setMovingNode(node);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const handleDelete = useCallback(() => {
+        if (!selectedId)
+            return;
+        triggerSFX('sfx:structure-delete');
+        deleteNode(selectedId);
+        setSelection({ selectedIds: [] });
+    }, [deleteNode, selectedId, setSelection]);
+    if (!(node && node.type === 'spawn' && selectedId))
+        return null;
+    const rotationDegrees = Math.round(((draftRotation ?? node.rotation) * 180) / Math.PI);
+    const storedRotationDegrees = Math.round((node.rotation * 180) / Math.PI);
+    return (_jsxs(PanelWrapper, { icon: "/icons/spawn-point.webp", onClose: handleClose, title: "Spawn Point", width: 300, children: [_jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: node.position[0] + 2, min: node.position[0] - 2, onChange: (value) => handleUpdate({ position: [value, node.position[1], node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: Math.round(node.position[0] * 100) / 100 }), _jsx(SliderControl, { label: "Y", max: node.position[1] + 2, min: node.position[1] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], value, node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: Math.round(node.position[1] * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: node.position[2] + 2, min: node.position[2] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], node.position[1], value] }), precision: 2, step: 0.01, unit: "m", value: Math.round(node.position[2] * 100) / 100 })] }), _jsx(PanelSection, { title: "Facing", children: _jsx(SliderControl, { label: "Yaw", max: storedRotationDegrees + 90, min: storedRotationDegrees - 90, onChange: handleRotationChange, onCommit: commitRotation, precision: 0, step: 1, unit: "\u00B0", value: rotationDegrees }) }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-4 w-4" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { className: "border-red-500/40 text-red-200 hover:bg-red-500/15", icon: _jsx(Trash2, { className: "h-4 w-4" }), label: "Delete", onClick: handleDelete })] }) })] }));
+}

package/dist/spawn/parametrics.d.ts

@@ -0,0 +1,8 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { SpawnNode } from './schema';
+/**
+ * Inspector descriptor for spawn. Tiny — spawn has only position + rotation,
+ * and Phase 4 will auto-render a 3-component vec3 + a yaw scalar from this.
+ */
+export declare const spawnParametrics: ParametricDescriptor<SpawnNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/spawn/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,oBAAoB,CAAC,SAAS,CAkB5D,CAAA"}

package/dist/spawn/parametrics.js

@@ -0,0 +1,23 @@
+/**
+ * Inspector descriptor for spawn. Tiny — spawn has only position + rotation,
+ * and Phase 4 will auto-render a 3-component vec3 + a yaw scalar from this.
+ */
+export const spawnParametrics = {
+    groups: [
+        {
+            label: 'Transform',
+            fields: [
+                { key: 'position', kind: 'vec3' },
+                // rotation on spawn is a scalar yaw (not vec3). Phase 4 will support a
+                // 'scalar-angle' kind; for now we expose it as a number with unit.
+                { key: 'rotation', kind: 'number', unit: 'rad', step: Math.PI / 12 },
+            ],
+        },
+    ],
+    // Stage E — kind-owned panel. Spawn has a derived position +
+    // rotation-degrees binding (legacy SpawnPanel converts radians to
+    // degrees in the slider and uses `useLiveTransforms` for smooth yaw
+    // dragging). Auto-inspector doesn't express the deg ↔ rad
+    // transform or the live-yaw preview yet — kept as a custom panel.
+    customPanel: () => import('./panel'),
+};

package/dist/spawn/renderer.d.ts

@@ -0,0 +1,16 @@
+import { type SpawnNode } from '@pascal-app/core';
+/**
+ * Registry-driven spawn renderer. Behaviorally identical to the legacy
+ * `@pascal-app/viewer/components/renderers/spawn/spawn-renderer.tsx` — same
+ * geometry and event surface. When the spawn definition lands
+ * in `builtinPlugin.nodes`, the Phase 0 dispatch shims switch the renderer
+ * here and the legacy one is short-circuited.
+ *
+ * Lives in `@pascal-app/nodes` (not viewer) so the kind owns its own render
+ * code. Phase 5's batch migration applies the same pattern to every node.
+ */
+declare const SpawnRenderer: ({ node }: {
+    node: SpawnNode;
+}) => import("react").JSX.Element;
+export default SpawnRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/spawn/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAOzB;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAkEnD,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/spawn/renderer.js

@@ -0,0 +1,47 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useLiveTransforms, useRegistry, } from '@pascal-app/core';
+import { createDefaultMaterial, useNodeEvents, useViewer } from '@pascal-app/viewer';
+import { useMemo, useRef } from 'react';
+import { Color, Shape } from 'three';
+const SPAWN_COLOR = new Color('#818cf8');
+/**
+ * Registry-driven spawn renderer. Behaviorally identical to the legacy
+ * `@pascal-app/viewer/components/renderers/spawn/spawn-renderer.tsx` — same
+ * geometry and event surface. When the spawn definition lands
+ * in `builtinPlugin.nodes`, the Phase 0 dispatch shims switch the renderer
+ * here and the legacy one is short-circuited.
+ *
+ * Lives in `@pascal-app/nodes` (not viewer) so the kind owns its own render
+ * code. Phase 5's batch migration applies the same pattern to every node.
+ */
+const SpawnRenderer = ({ node }) => {
+    const ref = useRef(null);
+    const handlers = useNodeEvents(node, 'spawn');
+    const liveOverride = useLiveNodeOverrides((state) => state.get(node.id));
+    const effectiveNode = useMemo(() => (liveOverride ? { ...node, ...liveOverride } : node), [node, liveOverride]);
+    const liveTransform = useLiveTransforms((state) => state.get(node.id));
+    const walkthroughMode = useViewer((state) => state.walkthroughMode);
+    const shading = useViewer((state) => state.shading);
+    useRegistry(node.id, 'spawn', ref);
+    const material = useMemo(() => {
+        const next = createDefaultMaterial('#818cf8', 0.42, shading);
+        next.emissive?.copy(SPAWN_COLOR);
+        if ('emissiveIntensity' in next)
+            next.emissiveIntensity = 0.08;
+        if ('metalness' in next)
+            next.metalness = 0.03;
+        next.needsUpdate = true;
+        return next;
+    }, [shading]);
+    const arrowShape = useMemo(() => {
+        const shape = new Shape();
+        shape.moveTo(0, 0.24);
+        shape.lineTo(-0.18, -0.14);
+        shape.lineTo(0.18, -0.14);
+        shape.closePath();
+        return shape;
+    }, []);
+    return (_jsxs("group", { position: liveTransform?.position ?? effectiveNode.position, ref: ref, rotation: [0, liveTransform?.rotation ?? effectiveNode.rotation, 0], visible: !walkthroughMode && effectiveNode.visible !== false, children: [_jsxs("mesh", { position: [0, 0.09, 0], rotation: [-Math.PI / 2, 0, 0], ...handlers, children: [_jsx("ringGeometry", { args: [0.34, 0.48, 48] }), _jsx("primitive", { attach: "material", object: material })] }), _jsxs("mesh", { position: [0, 0.1, -0.52], rotation: [-Math.PI / 2, 0, 0], ...handlers, children: [_jsx("shapeGeometry", { args: [arrowShape] }), _jsx("primitive", { attach: "material", object: material })] }), _jsxs("mesh", { position: [0, 0.41, 0], ...handlers, children: [_jsx("boxGeometry", { args: [0.3, 0.54, 0.16] }), _jsx("primitive", { attach: "material", object: material })] }), _jsxs("mesh", { position: [0, 0.83, 0], ...handlers, children: [_jsx("boxGeometry", { args: [0.18, 0.18, 0.18] }), _jsx("primitive", { attach: "material", object: material })] })] }));
+};
+export default SpawnRenderer;

package/dist/spawn/schema.d.ts

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

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

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

package/dist/spawn/schema.js

@@ -0,0 +1,5 @@
+// Spawn's Zod schema lives in core today (and remains in the hand-maintained
+// AnyNode union until Phase 6 derives it from the registry). The registry
+// definition references it via this re-export so all consumers in
+// `@pascal-app/nodes` can import from one place.
+export { SpawnNode } from '@pascal-app/core';

package/dist/spawn/tool.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Registry-driven spawn placement tool. Reads `activeLevelId` from useViewer
+ * directly (no props), broadcasts placement via store updates + SFX, and
+ * uses the shared CursorSphere from @pascal-app/editor for visual parity
+ * with legacy placement tools. Snapping is mode-driven (grid + Figma-style
+ * alignment "lines"), matching the shelf / column build tools.
+ */
+declare const SpawnTool: () => import("react").JSX.Element | null;
+export default SpawnTool;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/spawn/tool.tsx"],"names":[],"mappings":"AAoCA;;;;;;GAMG;AACH,QAAA,MAAM,SAAS,0CAwGd,CAAA;AAED,eAAe,SAAS,CAAA"}

package/dist/spawn/tool.js

@@ -0,0 +1,109 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { collectAlignmentAnchors, emitter, SpawnNode, useScene, } from '@pascal-app/core';
+import { CursorSphere, getFloorStackPreviewPosition, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, movementSfxStepKey, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import { getLevelLocalSnappedPosition, resolveAlignedFloorPlacement, } from '../shared/floor-placement';
+function getExistingSpawnIds() {
+    const nodes = useScene.getState().nodes;
+    return Object.values(nodes)
+        .filter((node) => node.type === 'spawn')
+        .map((node) => node.id)
+        .sort();
+}
+/**
+ * Registry-driven spawn placement tool. Reads `activeLevelId` from useViewer
+ * directly (no props), broadcasts placement via store updates + SFX, and
+ * uses the shared CursorSphere from @pascal-app/editor for visual parity
+ * with legacy placement tools. Snapping is mode-driven (grid + Figma-style
+ * alignment "lines"), matching the shelf / column build tools.
+ */
+const SpawnTool = () => {
+    const activeLevelId = useViewer((state) => state.selection.levelId);
+    const cursorRef = useRef(null);
+    const previousSnapRef = useRef(null);
+    // Default spawn for the footprint anchors the alignment solver reads.
+    const previewNode = useMemo(() => SpawnNode.parse({ name: 'Spawn Point', position: [0, 0, 0], rotation: 0 }), []);
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        previousSnapRef.current = null;
+        const lastCursorRef = { current: null };
+        let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
+        const onGridMove = (event) => {
+            const { position, guides } = resolveAlignedFloorPlacement({
+                node: previewNode,
+                rawX: event.localPosition[0],
+                rawZ: event.localPosition[2],
+                gridStep: useEditor.getState().gridSnapStep,
+                candidates: alignmentCandidates,
+                showAlignment: isAlignmentGuideActive(),
+                applyAlignmentSnap: isMagneticSnapActive(),
+                bypassGrid: !isGridSnapActive(),
+            });
+            useAlignmentGuides.getState().set(guides);
+            const visualPosition = getFloorStackPreviewPosition({
+                node: previewNode,
+                position,
+                rotation: 0,
+                levelId: activeLevelId,
+            });
+            cursorRef.current?.position.set(...visualPosition);
+            lastCursorRef.current = position;
+            const nextSnapKey = movementSfxStepKey({
+                coords: [position[0], position[2]],
+                gridSnapActive: isGridSnapActive(),
+                gridStep: useEditor.getState().gridSnapStep,
+            });
+            const prev = previousSnapRef.current;
+            if (prev !== nextSnapKey) {
+                triggerSFX('sfx:grid-snap');
+                previousSnapRef.current = nextSnapKey;
+            }
+        };
+        const onGridClick = (event) => {
+            const next = lastCursorRef.current ??
+                getLevelLocalSnappedPosition(activeLevelId, event, useEditor.getState().gridSnapStep, !isGridSnapActive());
+            const [existingSpawnId, ...duplicates] = getExistingSpawnIds();
+            let placedId;
+            if (existingSpawnId) {
+                useScene.getState().updateNode(existingSpawnId, {
+                    parentId: activeLevelId,
+                    position: next,
+                    rotation: 0,
+                });
+                if (duplicates.length > 0) {
+                    useScene.getState().deleteNodes(duplicates);
+                }
+                placedId = existingSpawnId;
+            }
+            else {
+                const spawn = SpawnNode.parse({
+                    name: 'Spawn Point',
+                    position: next,
+                    rotation: 0,
+                });
+                useScene.getState().createNode(spawn, activeLevelId);
+                placedId = spawn.id;
+            }
+            useViewer.getState().setSelection({ selectedIds: [placedId] });
+            triggerSFX('sfx:structure-build');
+            alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
+            useAlignmentGuides.getState().clear();
+            useEditor.getState().setTool(null);
+            useEditor.getState().setMode('select');
+        };
+        emitter.on('grid:move', onGridMove);
+        emitter.on('grid:click', onGridClick);
+        return () => {
+            emitter.off('grid:move', onGridMove);
+            emitter.off('grid:click', onGridClick);
+            useAlignmentGuides.getState().clear();
+        };
+    }, [activeLevelId, previewNode]);
+    if (!activeLevelId)
+        return null;
+    return _jsx(CursorSphere, { color: "#818cf8", height: 2.2, ref: cursorRef });
+};
+export default SpawnTool;

package/dist/stair/definition.d.ts

@@ -0,0 +1,9 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { StairNode } from './schema';
+/**
+ * Stair — Stage A. Composite node like roof: owns overall framing,
+ * `stair-segment` children own per-flight geometry. Wrap-exports the
+ * legacy `StairRenderer` + `StairSystem`.
+ */
+export declare const stairDefinition: NodeDefinition<typeof StairNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAMpB,MAAM,kBAAkB,CAAA;AAkZzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA0G5D,CAAA"}