@pascal-app/nodes 0.1.1

package/dist/item/renderer.js

@@ -0,0 +1,425 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { deriveSlotId, getScaledDimensions, isSlotMaterialName, itemClipRegistry, LIBRARY_MATERIAL_REF_PREFIX, SCENE_MATERIAL_REF_PREFIX, toLibraryMaterialRef, useInteractive, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createDefaultMaterial, createSurfaceRoleMaterial, ErrorBoundary, glassMaterial, NodeRenderer, resolveCdnUrl, resolveMaterialRef, useItemLightPool, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useAnimations } from '@react-three/drei';
+import { Clone } from '@react-three/drei/core/Clone';
+import { useFrame, useLoader } from '@react-three/fiber';
+import { Suspense, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { MathUtils } from 'three';
+import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { positionLocal, smoothstep, time } from 'three/tsl';
+import { RoofFaceHostFrame } from '../shared/roof-face-host';
+import { cancelItemModelLoad, getUnavailableItemAsset, ItemGLTFLoader } from './model-loader';
+const getAuthoredSlotId = (material) => isSlotMaterialName(material.name) ? deriveSlotId(material.name) : null;
+function curatedRefFromMaterial(material) {
+    const raw = material.userData.pascal_material;
+    if (typeof raw !== 'string' || raw.length === 0)
+        return undefined;
+    if (raw.startsWith(LIBRARY_MATERIAL_REF_PREFIX) || raw.startsWith(SCENE_MATERIAL_REF_PREFIX)) {
+        return raw;
+    }
+    return toLibraryMaterialRef(raw);
+}
+const captureItemMeshMaterials = (mesh) => {
+    const userData = mesh.userData;
+    const captured = userData.pascalItemMaterialCapture;
+    if (captured?.captured) {
+        userData.slotId = captured.slotIds;
+        return captured;
+    }
+    if (Array.isArray(mesh.material)) {
+        const authoredMaterials = mesh.material.slice();
+        const slotIds = authoredMaterials.map(getAuthoredSlotId);
+        const curatedRefs = authoredMaterials.map(curatedRefFromMaterial);
+        const next = {
+            captured: true,
+            authoredMaterials,
+            curatedRefs,
+            slotIds,
+        };
+        userData.pascalItemMaterialCapture = next;
+        userData.slotId = slotIds;
+        return next;
+    }
+    const slotId = getAuthoredSlotId(mesh.material);
+    const curatedRef = curatedRefFromMaterial(mesh.material);
+    const next = {
+        captured: true,
+        authoredMaterials: mesh.material,
+        curatedRefs: curatedRef,
+        slotIds: slotId,
+    };
+    userData.pascalItemMaterialCapture = next;
+    userData.slotId = slotId;
+    return next;
+};
+const isCapturedMaterialArray = (captured) => Array.isArray(captured.authoredMaterials);
+const isGlassMaterial = (material) => material === glassMaterial || material.name.toLowerCase() === 'glass';
+const clampGeometryGroups = (mesh, matCount) => {
+    if (mesh.geometry.groups.length === 0)
+        return;
+    const needsClamp = mesh.geometry.groups.some((group) => group.materialIndex !== undefined && group.materialIndex >= matCount);
+    if (!needsClamp)
+        return;
+    mesh.geometry = mesh.geometry.clone();
+    for (const group of mesh.geometry.groups) {
+        if (group.materialIndex !== undefined && group.materialIndex >= matCount) {
+            group.materialIndex = 0;
+        }
+    }
+};
+const resolveItemMaterial = (authoredMaterial, slotId, curatedRef, { colorPreset, nodeSlots, sceneMaterials, shading, textures, }) => {
+    // Monochrome (textures off): collapse to the themed furnishing clay colour.
+    if (!textures)
+        return createSurfaceRoleMaterial('furnishing', colorPreset);
+    if (authoredMaterial.name.toLowerCase() === 'glass')
+        return glassMaterial;
+    if (slotId != null) {
+        const override = resolveMaterialRef(nodeSlots?.[slotId], sceneMaterials, shading);
+        if (override)
+            return override;
+        const curated = resolveMaterialRef(curatedRef, sceneMaterials, shading);
+        if (curated)
+            return curated;
+        return authoredMaterial;
+    }
+    // Colored (textures on): show the item's real authored material — its
+    // textures, vertex colours, and default colours — for every item, not just
+    // slot-authored ones (no more strip-to-clay default).
+    return authoredMaterial;
+};
+const BrokenItemFallback = ({ node }) => {
+    const handlers = useNodeEvents(node, 'item');
+    const shading = useViewer((s) => s.shading);
+    const isExporting = useViewer((s) => s.isExporting);
+    const [w, h, d] = getScaledDimensions(node);
+    const material = useMemo(() => {
+        const next = createDefaultMaterial('#ef4444', 1, shading);
+        next.opacity = 0.6;
+        next.transparent = true;
+        next.wireframe = true;
+        next.needsUpdate = true;
+        return next;
+    }, [shading]);
+    // Debug affordance only — a bake must never ship the red placeholder box
+    // (observed baked into a prod artifact when an item GLB 504'd mid-capture).
+    if (isExporting)
+        return null;
+    return (_jsxs("mesh", { "position-y": h / 2, ...handlers, children: [_jsx("boxGeometry", { args: [w, h, d] }), _jsx("primitive", { attach: "material", object: material })] }));
+};
+let itemDracoLoader = null;
+const configureItemModelLoader = (loader) => {
+    if (!itemDracoLoader) {
+        itemDracoLoader = new DRACOLoader(loader.manager);
+        itemDracoLoader.setDecoderPath('https://www.gstatic.com/draco/versioned/decoders/1.5.5/');
+    }
+    loader.setDRACOLoader(itemDracoLoader);
+    loader.setMeshoptDecoder(MeshoptDecoder);
+};
+const useItemGltf = (url) => useLoader(ItemGLTFLoader, url, configureItemModelLoader);
+const unavailableAssetConsumers = new Map();
+const unavailableFailureConsumers = new Map();
+const retainUnavailableConsumer = (entries, key) => {
+    const entry = entries.get(key) ?? { consumers: 0, timer: null };
+    if (entry.timer !== null) {
+        clearTimeout(entry.timer);
+        entry.timer = null;
+    }
+    entry.consumers += 1;
+    entries.set(key, entry);
+};
+const releaseUnavailableConsumer = (entries, key, onLastRelease) => {
+    const entry = entries.get(key);
+    if (!entry)
+        return;
+    entry.consumers = Math.max(0, entry.consumers - 1);
+    if (entry.consumers > 0 || entry.timer !== null)
+        return;
+    // A zero-delay release distinguishes a real unmount from Strict Mode's
+    // immediate setup-cleanup-setup cycle and same-tick replacements.
+    entry.timer = setTimeout(() => {
+        if (entry.consumers > 0 || entries.get(key) !== entry)
+            return;
+        entries.delete(key);
+        onLastRelease();
+    }, 0);
+};
+const UnavailableItemModel = ({ markSettled, node, url, }) => {
+    useEffect(() => {
+        retainUnavailableConsumer(unavailableFailureConsumers, node.id);
+        if (url)
+            retainUnavailableConsumer(unavailableAssetConsumers, url);
+        markSettled();
+        useViewer.getState().reportItemLoadFailure(node.id, url);
+        return () => {
+            releaseUnavailableConsumer(unavailableFailureConsumers, node.id, () => useViewer.getState().clearItemLoadFailure(node.id));
+            if (url) {
+                releaseUnavailableConsumer(unavailableAssetConsumers, url, () => {
+                    cancelItemModelLoad(url);
+                    useLoader.clear(ItemGLTFLoader, url);
+                });
+            }
+        };
+    }, [markSettled, node.id, url]);
+    return _jsx(BrokenItemFallback, { node: node });
+};
+/**
+ * Expected network failures resolve through ItemGLTFLoader as an unavailable
+ * scene so they never become React render errors. Parse and renderer failures
+ * still reach this boundary and remain visible to developers.
+ */
+const ModelWithRetry = ({ node, setSettled, }) => {
+    const [renderFailed, setRenderFailed] = useState(false);
+    const url = resolveCdnUrl(node.asset.src) || '';
+    const markSettled = useCallback(() => setSettled(true), [setSettled]);
+    // Clear before child passive completion effects; a parent passive clear would run after them.
+    useLayoutEffect(() => {
+        setSettled(false);
+    }, [setSettled]);
+    useEffect(() => {
+        if (!renderFailed)
+            return;
+        markSettled();
+        useViewer.getState().reportItemLoadFailure(node.id, url);
+        return () => useViewer.getState().clearItemLoadFailure(node.id);
+    }, [markSettled, node.id, renderFailed, url]);
+    if (!url)
+        return _jsx(UnavailableItemModel, { markSettled: markSettled, node: node, url: url });
+    return (_jsx(ErrorBoundary, { fallback: _jsx(BrokenItemFallback, { node: node }), onError: () => setRenderFailed(true), scope: "item-model", children: _jsx(Suspense, { fallback: _jsx(PreviewModel, { node: node }), children: _jsx(ModelRenderer, { markSettled: markSettled, node: node }) }) }));
+};
+export const ItemRenderer = ({ node: storeNode }) => {
+    const ref = useRef(null);
+    useRegistry(storeNode.id, storeNode.type, ref);
+    // "Settled" = the model resolved, terminally failed (skipped), or was never
+    // expected. `ItemSystem` holds the dirty mark until then, so scene-ready
+    // (and headless bakes) wait for real item content instead of exporting the
+    // loading placeholder. A model swap un-settles (ModelWithRetry's mount
+    // effect via its URL key) so the replacement load is awaited too.
+    const setSettled = useCallback((value) => {
+        const group = ref.current;
+        if (group)
+            group.userData.itemModelSettled = value;
+    }, []);
+    // Merge live drag overrides so the mesh transforms in real time during a
+    // drag (e.g. the in-world rotate gizmo). The handle writes the in-flight
+    // rotation to `useLiveNodeOverrides` on every pointer move and commits to
+    // the store only on release — without this merge the item would stay put
+    // until commit.
+    const liveOverrides = useLiveNodeOverrides((state) => state.get(storeNode.id));
+    const node = useMemo(() => (liveOverrides ? { ...storeNode, ...liveOverrides } : storeNode), [storeNode, liveOverrides]);
+    const roomClearPreview = node.roomClearPreview === true;
+    useEffect(() => {
+        if (roomClearPreview)
+            setSettled(true);
+    }, [roomClearPreview, setSettled]);
+    const content = (_jsx("group", { position: node.position, ref: ref, rotation: node.rotation, visible: node.visible, children: roomClearPreview ? (_jsx(ClearPreviewModel, { node: node })) : (_jsxs(_Fragment, { children: [_jsx(ModelWithRetry, { node: node, setSettled: setSettled }, node.asset.src ?? 'no-src'), node.children?.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] })) }));
+    if (!node.roofSegmentId)
+        return content;
+    return (_jsx(RoofFaceHostFrame, { roofFace: node.roofFace, roofSegmentId: node.roofSegmentId, children: content }));
+};
+const previewOpacity = smoothstep(0.42, 0.55, positionLocal.y.add(time.mul(-0.2)).mul(10).fract());
+const previewMaterialCache = new Map();
+function getPreviewMaterial(shading) {
+    const cached = previewMaterialCache.get(shading);
+    if (cached)
+        return cached;
+    const material = createDefaultMaterial('#cccccc', 1, shading);
+    material.depthTest = false;
+    material.opacityNode = previewOpacity;
+    material.transparent = true;
+    material.needsUpdate = true;
+    previewMaterialCache.set(shading, material);
+    return material;
+}
+const PreviewModel = ({ node }) => {
+    const shading = useViewer((s) => s.shading);
+    const isExporting = useViewer((s) => s.isExporting);
+    // Loading placeholder — must never land in an exported GLB.
+    if (isExporting)
+        return null;
+    return (_jsx("mesh", { material: getPreviewMaterial(shading), "position-y": node.asset.dimensions[1] / 2, children: _jsx("boxGeometry", { args: [node.asset.dimensions[0], node.asset.dimensions[1], node.asset.dimensions[2]] }) }));
+};
+const ClearPreviewModel = ({ node }) => {
+    const shading = useViewer((s) => s.shading);
+    const [w, h, d] = getScaledDimensions(node);
+    const material = useMemo(() => {
+        const next = createDefaultMaterial('#ef4444', 1, shading);
+        next.depthTest = false;
+        next.opacity = 0.35;
+        next.transparent = true;
+        next.wireframe = true;
+        next.needsUpdate = true;
+        return next;
+    }, [shading]);
+    return (_jsx("mesh", { material: material, "position-y": h / 2, children: _jsx("boxGeometry", { args: [w, h, d] }) }));
+};
+const multiplyScales = (a, b) => [a[0] * b[0], a[1] * b[1], a[2] * b[2]];
+const ModelRenderer = ({ node, markSettled }) => {
+    const gltf = useItemGltf(resolveCdnUrl(node.asset.src) || '');
+    const unavailable = getUnavailableItemAsset(gltf);
+    if (unavailable) {
+        return _jsx(UnavailableItemModel, { markSettled: markSettled, node: node, url: unavailable.url });
+    }
+    return _jsx(LoadedModelRenderer, { gltf: gltf, markSettled: markSettled, node: node });
+};
+const LoadedModelRenderer = ({ gltf: { scene, nodes, animations }, node, markSettled, }) => {
+    const ref = useRef(null);
+    const { actions } = useAnimations(animations, ref);
+    // Mounting past the suspense gate means the GLB resolved — the item's build
+    // work is done (`ItemSystem` may clear its dirty mark, scene-ready may fire).
+    useEffect(() => {
+        markSettled();
+    }, [markSettled]);
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneMaterials = useScene((s) => s.materials);
+    // Freeze the interactive definition at mount — asset schemas don't change at runtime
+    const interactiveRef = useRef(node.asset.interactive);
+    if (nodes.cutout) {
+        nodes.cutout.visible = false;
+    }
+    const handlers = useNodeEvents(node, 'item');
+    useEffect(() => {
+        if (!node.parentId)
+            return;
+        useScene.getState().markDirty(node.parentId);
+    }, [node.parentId]);
+    useEffect(() => {
+        const interactive = interactiveRef.current;
+        if (!interactive)
+            return;
+        useInteractive.getState().initItem(node.id, interactive);
+        return () => useInteractive.getState().removeItem(node.id);
+    }, [node.id]);
+    useLayoutEffect(() => {
+        const root = ref.current;
+        if (!root)
+            return;
+        const meshEntries = [];
+        root.traverse((child) => {
+            if (!child.isMesh)
+                return;
+            const mesh = child;
+            if (mesh.name === 'cutout') {
+                child.visible = false;
+            }
+            const captured = captureItemMeshMaterials(mesh);
+            if (mesh.name !== 'cutout')
+                meshEntries.push({ mesh, captured });
+        });
+        const materialOptions = {
+            colorPreset,
+            nodeSlots: node.slots,
+            sceneMaterials,
+            shading,
+            textures,
+        };
+        for (const { mesh, captured } of meshEntries) {
+            let hasGlass = false;
+            if (isCapturedMaterialArray(captured)) {
+                const nextMaterials = captured.authoredMaterials.map((authoredMaterial, index) => resolveItemMaterial(authoredMaterial, captured.slotIds[index] ?? null, captured.curatedRefs[index], materialOptions));
+                mesh.material = nextMaterials;
+                hasGlass = nextMaterials.some(isGlassMaterial);
+                clampGeometryGroups(mesh, nextMaterials.length);
+            }
+            else {
+                const nextMaterial = resolveItemMaterial(captured.authoredMaterials, captured.slotIds, captured.curatedRefs, materialOptions);
+                mesh.material = nextMaterial;
+                hasGlass = isGlassMaterial(nextMaterial);
+            }
+            mesh.castShadow = !hasGlass;
+            mesh.receiveShadow = !hasGlass;
+        }
+    }, [shading, textures, colorPreset, node.slots, sceneMaterials]);
+    const interactive = interactiveRef.current;
+    const animEffect = interactive?.effects.find((e) => e.kind === 'animation') ?? null;
+    const lightEffects = interactive?.effects.filter((e) => e.kind === 'light') ?? [];
+    // Expose this item's ambient clip (e.g. a fan's spin) to the GLB bake. The
+    // catalog GLB owns the clip; it isn't in the scene graph, so the export can't
+    // find it without this registry. The bake retargets it onto the baked subtree.
+    useEffect(() => {
+        if (!animEffect)
+            return;
+        const clipName = animEffect.clips.on ?? animEffect.clips.loop;
+        const clip = clipName ? animations.find((c) => c.name === clipName) : undefined;
+        if (!clip)
+            return;
+        itemClipRegistry.set(node.id, { clip, loop: true });
+        return () => {
+            itemClipRegistry.delete(node.id);
+        };
+    }, [node.id, animEffect, animations]);
+    // useGLTF caches scenes, and Clone shares child geometry/material references.
+    // Undo can unmount one item while another clone of the same asset still needs them.
+    return (_jsxs(_Fragment, { children: [_jsx(Clone, { dispose: null, object: scene, position: node.asset.offset, ref: ref, rotation: node.asset.rotation, scale: multiplyScales(node.asset.scale || [1, 1, 1], node.scale || [1, 1, 1]), ...handlers }), animations.length > 0 && (_jsx(ItemAnimation, { actions: actions, animations: animations, animEffect: animEffect, interactive: interactive ?? null, nodeId: node.id })), lightEffects.map((effect, i) => (_jsx(ItemLightRegistrar, { effect: effect, index: i, interactive: interactive, nodeId: node.id }, i)))] }));
+};
+const ItemAnimation = ({ nodeId, animEffect, interactive, actions, animations, }) => {
+    const activeClipRef = useRef(null);
+    const fadingOutRef = useRef(null);
+    // Reactive: derive target clip name — only re-renders when the clip name itself changes
+    const targetClip = useInteractive((s) => {
+        const values = s.items[nodeId]?.controlValues;
+        if (!animEffect)
+            return animations[0]?.name ?? null;
+        const toggleIndex = interactive.controls.findIndex((c) => c.kind === 'toggle');
+        const isOn = toggleIndex >= 0 ? Boolean(values?.[toggleIndex]) : false;
+        return isOn
+            ? (animEffect.clips.on ?? null)
+            : (animEffect.clips.off ?? animEffect.clips.loop ?? null);
+    });
+    // When target clip changes: kick off the transition
+    useEffect(() => {
+        // Cancel any ongoing fade-out immediately
+        if (fadingOutRef.current) {
+            fadingOutRef.current.timeScale = 0;
+            fadingOutRef.current = null;
+        }
+        // Move current clip to fade-out
+        if (activeClipRef.current && activeClipRef.current !== targetClip) {
+            const old = actions[activeClipRef.current];
+            if (old?.isRunning())
+                fadingOutRef.current = old;
+        }
+        // Start new clip at timeScale 0.01 (as 0 would cause isRunning to be false and thus not play at all), then fade in to 1
+        activeClipRef.current = targetClip;
+        if (targetClip) {
+            const next = actions[targetClip];
+            if (next) {
+                next.timeScale = 0.01;
+                next.play();
+            }
+        }
+    }, [targetClip, actions]);
+    // useFrame: only lerping — no logic
+    useFrame((_, delta) => {
+        if (fadingOutRef.current) {
+            const action = fadingOutRef.current;
+            action.timeScale = MathUtils.lerp(action.timeScale, 0, Math.min(delta * 5, 1));
+            if (action.timeScale < 0.01) {
+                action.timeScale = 0;
+                fadingOutRef.current = null;
+            }
+        }
+        if (activeClipRef.current) {
+            const action = actions[activeClipRef.current];
+            if (action?.isRunning() && action.timeScale < 1) {
+                action.timeScale = MathUtils.lerp(action.timeScale, 1, Math.min(delta * 5, 1));
+                if (1 - action.timeScale < 0.01)
+                    action.timeScale = 1;
+            }
+        }
+    });
+    return null;
+};
+const ItemLightRegistrar = ({ nodeId, effect, interactive, index, }) => {
+    useEffect(() => {
+        const key = `${nodeId}:${index}`;
+        useItemLightPool.getState().register(key, nodeId, effect, interactive);
+        return () => useItemLightPool.getState().unregister(key);
+    }, [nodeId, index, effect, interactive]);
+    return null;
+};
+export default ItemRenderer;

package/dist/item/schema.d.ts

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

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

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

package/dist/item/schema.js

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

package/dist/item/system.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Registry-driven item system bundle.
+ *
+ *  - **`ItemSystem`** — applies attachTo-driven transforms each frame
+ *    (wall-side z-offset, slab elevation, ceiling mounting).
+ *  - **`ItemLightSystem`** — manages light sources attached to items
+ *    (lamps, ceiling lights, etc.).
+ */
+declare const ItemSystems: () => import("react").JSX.Element;
+export default ItemSystems;
+//# sourceMappingURL=system.d.ts.map

package/dist/item/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/item/system.tsx"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,QAAA,MAAM,WAAW,mCAOhB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/item/system.js

@@ -0,0 +1,15 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ItemLightSystem, ItemSystem } from '@pascal-app/viewer';
+/**
+ * Registry-driven item system bundle.
+ *
+ *  - **`ItemSystem`** — applies attachTo-driven transforms each frame
+ *    (wall-side z-offset, slab elevation, ceiling mounting).
+ *  - **`ItemLightSystem`** — manages light sources attached to items
+ *    (lamps, ceiling lights, etc.).
+ */
+const ItemSystems = () => {
+    return (_jsxs(_Fragment, { children: [_jsx(ItemSystem, {}), _jsx(ItemLightSystem, {})] }));
+};
+export default ItemSystems;

package/dist/item/tool.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/item/tool.tsx"],"names":[],"mappings":"AA4CA,iBAAS,QAAQ,uCAIhB;AAED,eAAe,QAAQ,CAAA"}

package/dist/item/tool.js

@@ -0,0 +1,46 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { triggerSFX, useDraftNode, useEditor, usePlacementCoordinator } from '@pascal-app/editor';
+/**
+ * Registry-driven item placement tool. Mounted by `ToolManager` when
+ * `useEditor.tool === 'item'` (the catalog picker is what selects which
+ * asset; this tool handles the cursor follow + click-to-commit flow).
+ *
+ * Wraps the same `usePlacementCoordinator` + `useDraftNode` primitives
+ * the move-tool uses. The placement coordinator runs surface strategies
+ * (floor / wall / ceiling / item-surface) so the same cursor logic
+ * handles wall-mounted artwork, floor furniture, ceiling fans, and
+ * nested items on tables.
+ *
+ * Replaces the legacy `editor/src/components/tools/item/item-tool.tsx`.
+ * The `tools` map in `tool-manager.tsx` no longer needs an `item:` entry
+ * — `getRegistryTool('item')` finds this through `def.tool`.
+ */
+function ItemPlacementContent({ selectedItem }) {
+    const draftNode = useDraftNode();
+    const cursor = usePlacementCoordinator({
+        asset: selectedItem,
+        draftNode,
+        initDraft: (gridPosition) => {
+            // Only floor items get a draft on mount; wall / ceiling items are
+            // created lazily by the placement coordinator when the cursor
+            // enters a surface (so the draft doesn't appear at world origin
+            // before the first move event).
+            if (selectedItem && !selectedItem.attachTo) {
+                draftNode.create(gridPosition, selectedItem);
+            }
+        },
+        onCommitted: () => {
+            triggerSFX('sfx:item-place');
+            return useEditor.getState().getContinuation('point') === 'repeat';
+        },
+    });
+    return _jsx(_Fragment, { children: cursor });
+}
+function ItemTool() {
+    const selectedItem = useEditor((state) => state.selectedItem);
+    if (!selectedItem)
+        return null;
+    return _jsx(ItemPlacementContent, { selectedItem: selectedItem });
+}
+export default ItemTool;

package/dist/level/definition.d.ts

@@ -0,0 +1,9 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { LevelNode } from './schema';
+/**
+ * Level — Stage A. Container for walls / slabs / ceilings / etc. on
+ * a single floor. `LevelSystem` does level-wide work (Y-position
+ * snapping to true positions when levels reorder); wrap-exported.
+ */
+export declare const levelDefinition: NodeDefinition<typeof LevelNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/level/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpF,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAoD5D,CAAA"}

package/dist/level/definition.js

@@ -0,0 +1,55 @@
+import { LevelNode as LevelNodeSchema } from '@pascal-app/core';
+import { levelParametrics } from './parametrics';
+import { LevelNode } from './schema';
+/**
+ * Level — Stage A. Container for walls / slabs / ceilings / etc. on
+ * a single floor. `LevelSystem` does level-wide work (Y-position
+ * snapping to true positions when levels reorder); wrap-exported.
+ */
+export const levelDefinition = {
+    kind: 'level',
+    schemaVersion: 1,
+    schema: LevelNode,
+    category: 'site',
+    defaults: () => {
+        const stub = LevelNodeSchema.parse({ id: 'level_default', type: 'level' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        // Level is a container — selection happens via the sidebar tree
+        // and the floating level switcher, never via 3D click. Declaring
+        // `selectable` here would make `getSelectableKinds()` add the
+        // kind to `SelectionManager`'s subscription list, and the event
+        // would fire on every wall/slab/ceiling click that bubbled to the
+        // level group — selecting the level instead of the actual node
+        // hit. Legacy `allTypes` deliberately omitted containers; we
+        // mirror that.
+        duplicable: false,
+        deletable: true,
+        // Container kind — saving a level as a standalone preset has no
+        // meaning (its contents make sense only inside a building).
+        presettable: false,
+    },
+    parametrics: levelParametrics,
+    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
+    dirtyTracking: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        priority: 1,
+    },
+    presentation: {
+        label: 'Level',
+        description: 'A single floor of a building, holding walls / slabs / ceilings / items.',
+        icon: { kind: 'url', src: '/icons/level.webp' },
+        paletteSection: 'site',
+        paletteOrder: 7,
+    },
+    mcp: {
+        description: 'A level (floor) container under a building.',
+    },
+};

package/dist/level/index.d.ts

@@ -0,0 +1,2 @@
+export { levelDefinition } from './definition';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/level/index.js

@@ -0,0 +1 @@
+export { levelDefinition } from './definition';

package/dist/level/parametrics.d.ts

@@ -0,0 +1,3 @@
+import type { LevelNode, ParametricDescriptor } from '@pascal-app/core';
+export declare const levelParametrics: ParametricDescriptor<LevelNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/level/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEvE,eAAO,MAAM,gBAAgB,EAAE,oBAAoB,CAAC,SAAS,CAE5D,CAAA"}

package/dist/level/parametrics.js

@@ -0,0 +1,3 @@
+export const levelParametrics = {
+    groups: [],
+};

package/dist/level/renderer.d.ts

@@ -0,0 +1,6 @@
+import { type LevelNode } from '@pascal-app/core';
+export declare const LevelRenderer: ({ node }: {
+    node: LevelNode;
+}) => import("react").JSX.Element;
+export default LevelRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/level/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,kBAAkB,CAAA;AAK9D,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAa1D,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/level/renderer.js

@@ -0,0 +1,12 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRegistry } from '@pascal-app/core';
+import { NodeRenderer, useNodeEvents } from '@pascal-app/viewer';
+import { useRef } from 'react';
+export const LevelRenderer = ({ node }) => {
+    const ref = useRef(null);
+    useRegistry(node.id, node.type, ref);
+    const handlers = useNodeEvents(node, 'level');
+    return (_jsx("group", { ref: ref, ...handlers, children: node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))) }));
+};
+export default LevelRenderer;

package/dist/level/schema.d.ts

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

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

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

package/dist/level/schema.js

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

package/dist/level/system.d.ts

@@ -0,0 +1,3 @@
+import { LevelSystem } from '@pascal-app/viewer';
+export default LevelSystem;
+//# sourceMappingURL=system.d.ts.map