@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/beam/renderer.js

@@ -0,0 +1,36 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BEAM_MATERIAL_LIBRARY_REFS, beamTopElevation, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createSurfaceRoleMaterial, resolveSlotDefaultMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import { beamBox, buildBeamGeometry } from './geometry.js';
+/** How a beam of `material` looks: its library material, or the plain surface colour when textures are off. */
+export function useBeamMaterial(material) {
+    const shading = useViewer((state) => state.shading);
+    const textures = useViewer((state) => state.textures);
+    const colorPreset = useViewer((state) => state.colorPreset);
+    return useMemo(() => textures
+        ? resolveSlotDefaultMaterial(BEAM_MATERIAL_LIBRARY_REFS[material], shading)
+        : createSurfaceRoleMaterial('wall', colorPreset), [material, shading, textures, colorPreset]);
+}
+/**
+ * A beam: its solid laid along the centreline in its level, the top where the beam's top resolves
+ * (`beamTopElevation`: its own, else the ceiling plane over it). Reads live overrides, so a drag
+ * in either view moves it at once.
+ */
+export default function BeamRenderer({ node: stored }) {
+    const ref = useRef(null);
+    useRegistry(stored.id, 'beam', ref);
+    const live = useLiveNodeOverrides((state) => state.overrides.get(stored.id));
+    const node = useMemo(() => (live ? { ...stored, ...live } : stored), [stored, live]);
+    const handlers = useNodeEvents(node, 'beam');
+    const top = useScene((state) => beamTopElevation(state.nodes, node));
+    const material = useBeamMaterial(node.material);
+    const placed = beamBox(node, top);
+    const length = placed?.size[0] ?? 0;
+    const geometry = useMemo(() => length > 0
+        ? buildBeamGeometry({ width: node.width, depth: node.depth, plies: node.plies, material: node.material }, length)
+        : null, [length, node.width, node.depth, node.plies, node.material]);
+    useEffect(() => () => geometry?.dispose(), [geometry]);
+    return (_jsx("group", { ref: ref, children: placed && geometry && (_jsx("mesh", { castShadow: true, geometry: geometry, material: material, position: placed.position, receiveShadow: true, "rotation-y": placed.rotationY, ...handlers })) }));
+}

package/dist/beam/schema.d.ts

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

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

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

package/dist/beam/schema.js

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

package/dist/beam/tool.d.ts

@@ -0,0 +1,13 @@
+import { type BeamNode } from '@pascal-app/core';
+import { type PlacementPreviewDimension } from '@pascal-app/editor';
+/** The draft's length, as a dimension along it in the plan (the 3D view prints its own label). */
+export declare function beamDraftDimensions(beam: BeamNode): PlacementPreviewDimension[];
+/**
+ * The beam tool in 2D-only view: the 3D tool lives in the canvas, which never renders while its
+ * pane is hidden. The plan draws the draft from the placement preview. Split and 3D views keep the
+ * 3D tool as the one owner.
+ */
+export declare function BeamFloorplanTool(): null;
+declare const BeamTool: () => import("react").JSX.Element | null;
+export default BeamTool;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/beam/tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,QAAQ,EAQd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAML,KAAK,yBAAyB,EAO/B,MAAM,oBAAoB,CAAA;AAsB3B,kGAAkG;AAClG,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,yBAAyB,EAAE,CAc/E;AAmGD;;;;GAIG;AACH,wBAAgB,iBAAiB,SAGhC;AAED,QAAA,MAAM,QAAQ,0CA6Cb,CAAA;eAEc,QAAQ"}

package/dist/beam/tool.js

@@ -0,0 +1,152 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { beamPlan, beamTopElevation, emitter, formatLinearMeasurement, sceneRegistry, useScene, } from '@pascal-app/core';
+import { CursorSphere, DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, isSegmentLongEnough, markToolCancelConsumed, triggerSFX, useEditor, usePlacementPreview, useWallSnapIndicator, visibleScene, } from '@pascal-app/editor';
+import { getSceneTheme, useViewer } from '@pascal-app/viewer';
+import { createPortal } from '@react-three/fiber';
+import { useEffect, useMemo, useState } from 'react';
+import { DoubleSide } from 'three';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+import { stopPlacementCommitPropagation, subscribeFloorPlacementClicks, } from '../shared/floor-placement.js';
+import { draftBeam, snapBeamPoint } from './drafting.js';
+import { beamBox, buildBeamGeometry } from './geometry.js';
+const ghostMaterial = new MeshBasicNodeMaterial({
+    color: '#f59e0b',
+    depthWrite: false,
+    opacity: 0.5,
+    side: DoubleSide,
+    transparent: true,
+});
+/** The draft's length, as a dimension along it in the plan (the 3D view prints its own label). */
+export function beamDraftDimensions(beam) {
+    const plan = beamPlan(beam);
+    if (plan.length < 0.05)
+        return [];
+    return [
+        {
+            id: 'beam-length',
+            start: [plan.start[0], 0, plan.start[1]],
+            end: [plan.end[0], 0, plan.end[1]],
+            offsetNormal: plan.normal,
+            offsetDistance: plan.width / 2 + 0.25,
+            value: plan.length,
+            renderIn3d: false,
+        },
+    ];
+}
+/**
+ * Drafting beams from the grid events both views send: a click sets the start, the next ends the
+ * beam and starts the next one there, so a porch's run is drawn corner to corner; Esc ends the run.
+ * Points snap as walls do (wall ends, faces and crossings, other beams' ends and runs, post
+ * centres, the grid, the angle steps off the start); Alt places freely. The beam takes the Build
+ * panel's size, material and top (`useBeamDraft`), or the preset a host armed the tool with.
+ * `enabled` off, it stands aside.
+ */
+function useBeamDrafting(enabled) {
+    const levelId = useViewer((state) => state.selection.levelId);
+    const [draft, setDraft] = useState(null);
+    const [cursor, setCursor] = useState(null);
+    useEffect(() => {
+        if (!(enabled && levelId))
+            return;
+        let start = null;
+        let last = null;
+        setDraft(null);
+        const snap = (event) => {
+            const { point, snap: caught } = snapBeamPoint({
+                point: [event.localPosition[0], event.localPosition[2]],
+                nodes: useScene.getState().nodes,
+                levelId,
+                start,
+                free: event.nativeEvent?.altKey === true,
+            });
+            if (caught)
+                useWallSnapIndicator.getState().set({ x: point[0], z: point[1], kind: caught });
+            else
+                useWallSnapIndicator.getState().clear();
+            return point;
+        };
+        const make = (from, to, fields) => draftBeam(from, to, levelId, useScene.getState().nodes, undefined, useEditor.getState().toolDefaults.beam, fields);
+        const show = (next) => {
+            setDraft(next);
+            if (next)
+                usePlacementPreview.getState().set(next, null, beamDraftDimensions(next));
+            else
+                usePlacementPreview.getState().clear();
+        };
+        const onMove = (event) => {
+            const point = snap(event);
+            if (last && point[0] === last[0] && point[1] === last[1])
+                return;
+            last = point;
+            setCursor([point[0], event.localPosition[1], point[1]]);
+            show(start && isSegmentLongEnough(start, point) ? make(start, point) : null);
+        };
+        const onClick = (event) => {
+            const point = last ?? snap(event);
+            stopPlacementCommitPropagation(event);
+            if (!start) {
+                start = point;
+                triggerSFX('sfx:grid-snap');
+                return;
+            }
+            if (!isSegmentLongEnough(start, point))
+                return;
+            const count = Object.values(useScene.getState().nodes).filter((node) => node.type === 'beam').length;
+            const beam = make(start, point, { name: `Beam ${count + 1}` });
+            useScene.getState().createNode(beam, levelId);
+            triggerSFX('sfx:structure-build');
+            // The run goes on from the end just placed.
+            start = point;
+            show(null);
+        };
+        const onCancel = () => {
+            if (!start)
+                return;
+            markToolCancelConsumed();
+            start = null;
+            show(null);
+        };
+        emitter.on('grid:move', onMove);
+        emitter.on('tool:cancel', onCancel);
+        const unsubscribeClicks = subscribeFloorPlacementClicks(onClick);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('tool:cancel', onCancel);
+            unsubscribeClicks();
+            usePlacementPreview.getState().clear();
+            useWallSnapIndicator.getState().clear();
+            setDraft(null);
+            setCursor(null);
+        };
+    }, [enabled, levelId]);
+    return { levelId, draft, cursor };
+}
+/**
+ * The beam tool in 2D-only view: the 3D tool lives in the canvas, which never renders while its
+ * pane is hidden. The plan draws the draft from the placement preview. Split and 3D views keep the
+ * 3D tool as the one owner.
+ */
+export function BeamFloorplanTool() {
+    useBeamDrafting(useEditor((state) => visibleScene(state) === '2d'));
+    return null;
+}
+const BeamTool = () => {
+    const { levelId, draft, cursor } = useBeamDrafting(useEditor((state) => visibleScene(state) !== '2d'));
+    const top = useScene((state) => (draft ? beamTopElevation(state.nodes, draft) : 0));
+    const unit = useViewer((state) => state.unit);
+    const metricNotation = useViewer((state) => state.metricNotation);
+    const dark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
+    const placed = draft ? beamBox(draft, top) : null;
+    const length = placed?.size[0] ?? 0;
+    const geometry = useMemo(() => (draft && length > 0 ? buildBeamGeometry(draft, length) : null), [draft, length]);
+    useEffect(() => () => geometry?.dispose(), [geometry]);
+    const level = levelId ? sceneRegistry.nodes.get(levelId) : undefined;
+    if (!levelId)
+        return null;
+    return (_jsxs(_Fragment, { children: [cursor && _jsx(CursorSphere, { position: cursor }), placed &&
+                geometry &&
+                level &&
+                createPortal(_jsxs("group", { children: [_jsx("mesh", { geometry: geometry, material: ghostMaterial, position: placed.position, raycast: () => { }, renderOrder: 2, "rotation-y": placed.rotationY }), _jsx(DraftMeasurementLabel, { color: dark ? '#ffffff' : '#111111', label: formatLinearMeasurement(length, unit, metricNotation), position: [placed.position[0], top + DRAFT_LABEL_Y_OFFSET, placed.position[2]], shadowColor: dark ? '#111111' : '#ffffff' })] }), level)] }));
+};
+export default BeamTool;

package/dist/block/definition.d.ts

@@ -1,8 +1,68 @@
-import { type BlockNode as BlockNodeType, type NodeDefinition } from '@pascal-app/core';
-import { BlockNode } from './schema.js';
-export declare function blockBounds(node: BlockNodeType): {
-    size: [number, number, number];
-    center: [number, number, number];
-};
-export declare const blockDefinition: NodeDefinition<typeof BlockNode>;
+export declare const blockDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`block_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"block">>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+    topology: import("zod").ZodDefault<import("zod").ZodObject<{
+        vertices: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        }, import("zod/v4/core").$strip>>;
+        edges: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            vertexIds: import("zod").ZodTuple<[import("zod").ZodString, import("zod").ZodString], null>;
+        }, import("zod/v4/core").$strip>>;
+        faces: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            vertexIds: import("zod").ZodArray<import("zod").ZodString>;
+            materialSlot: import("zod").ZodDefault<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    slots: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    slotNames: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>>;
+export { blockBounds } from './definition.render.js';
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/block/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,IAAI,aAAa,EAG/B,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAmBpC,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa;UAMtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YACtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;EAalD;AAYD,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA8F5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/block/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAsE,CAAA;AAClG,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/block/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { BlockNode } from './schema.js';
+export declare const blockEditContribution: NodeEditContribution<typeof BlockNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/block/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/block/definition.edit.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAKvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAuBxE,CAAA"}

package/dist/block/definition.edit.js

@@ -0,0 +1,28 @@
+import { blockContextualHelp } from './contextual-help.js';
+import { buildBlockFloorplan } from './floorplan.js';
+import { blockPaint } from './paint.js';
+import { blockParametrics } from './parametrics.js';
+export const blockEditContribution = {
+    snapProfile: 'structural',
+    extensions: {
+        'pascal:editor/floorplan': {
+            tool: () => import('./tool.js'),
+            preferredView: '3d',
+        },
+        'pascal:editor/contextual-help': blockContextualHelp,
+    },
+    capabilities: {
+        paint: blockPaint,
+    },
+    floorplan: buildBlockFloorplan,
+    parametrics: blockParametrics,
+    affordanceTools: {
+        selection: () => import('./selection.js'),
+    },
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Left click', label: 'Place block' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/block/definition.js

@@ -1,144 +1,5 @@
-import { blockSlots, createBoxBlockTopology, } from '@pascal-app/core';
-import { perNodeGeometryBatchable } from '../shared/node-batch/batchable.js';
-import { blockContextualHelp } from './contextual-help.js';
-import { blockFaceHost } from './face-host.js';
-import { buildBlockFloorplan } from './floorplan.js';
-import { buildBlockGeometry } from './geometry.js';
-import { blockPaint } from './paint.js';
-import { blockParametrics } from './parametrics.js';
-import { BlockNode } from './schema.js';
-import { blockSurfaceProvider } from './surface.js';
-/** Bottom within this of the floor (and top above it): the block stands on the floor. */
-const BLOCK_ON_FLOOR_MAX_BOTTOM = 0.1;
-const BLOCK_ON_FLOOR_MIN_TOP = 0.01;
-/**
- * Floor collision is for blocks standing on the floor. Soffits, vaults,
- * gutters and mantels hang above floor placements, and foundation pads sit
- * under the floor, so neither blocks furniture nor gets refused when moved.
- */
-function blockRestsOnFloor(node) {
-    const { size, center } = blockBounds(node);
-    const bottom = node.position[1] + center[1] - size[1] / 2;
-    const top = node.position[1] + center[1] + size[1] / 2;
-    return bottom <= BLOCK_ON_FLOOR_MAX_BOTTOM && top > BLOCK_ON_FLOOR_MIN_TOP;
-}
-export function blockBounds(node) {
-    const xs = node.topology.vertices.map((vertex) => vertex.position[0]);
-    const ys = node.topology.vertices.map((vertex) => vertex.position[1]);
-    const zs = node.topology.vertices.map((vertex) => vertex.position[2]);
-    if (xs.length === 0) {
-        return {
-            size: [0, 0, 0],
-            center: [0, 0, 0],
-        };
-    }
-    const minX = Math.min(...xs);
-    const maxX = Math.max(...xs);
-    const minY = Math.min(...ys);
-    const maxY = Math.max(...ys);
-    const minZ = Math.min(...zs);
-    const maxZ = Math.max(...zs);
-    return {
-        size: [maxX - minX, maxY - minY, maxZ - minZ],
-        center: [(minX + maxX) / 2, (minY + maxY) / 2, (minZ + maxZ) / 2],
-    };
-}
-function footprintPosition(node, center) {
-    const cos = Math.cos(node.rotation);
-    const sin = Math.sin(node.rotation);
-    return [
-        node.position[0] + center[0] * cos + center[2] * sin,
-        node.position[1],
-        node.position[2] - center[0] * sin + center[2] * cos,
-    ];
-}
-export const blockDefinition = {
-    kind: 'block',
-    schemaVersion: 5,
-    schema: BlockNode,
-    category: 'structure',
-    surfaceRole: 'wall',
-    snapProfile: 'structural',
-    extensions: {
-        'pascal:editor/floorplan': {
-            tool: () => import('./tool.js'),
-            preferredView: '3d',
-        },
-        'pascal:editor/contextual-help': blockContextualHelp,
-    },
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        children: [],
-        position: [0, 0, 0],
-        rotation: 0,
-        topology: createBoxBlockTopology(),
-        slots: {},
-        slotNames: { body: 'Body' },
-    }),
-    capabilities: {
-        batchable: perNodeGeometryBatchable,
-        selectable: { hitVolume: 'bbox' },
-        surfaces: {
-            hosting: blockSurfaceProvider,
-            top: {
-                height: (rawNode) => {
-                    const node = rawNode;
-                    const { size, center } = blockBounds(node);
-                    return center[1] + size[1] / 2;
-                },
-            },
-            sides: { faces: 'all' },
-        },
-        movable: { axes: ['x', 'z'], gridSnap: true },
-        duplicable: { subtree: true },
-        deletable: true,
-        dragBounds: (rawNode) => blockBounds(rawNode),
-        floorPlaced: {
-            footprint: (rawNode) => {
-                const node = rawNode;
-                const { size, center } = blockBounds(node);
-                return {
-                    dimensions: size,
-                    position: footprintPosition(node, center),
-                    rotation: [0, node.rotation, 0],
-                };
-            },
-            collides: (rawNode) => blockRestsOnFloor(rawNode),
-        },
-        paint: blockPaint,
-        slots: (rawNode) => blockSlots(rawNode),
-        faceHost: blockFaceHost,
-    },
-    relations: {
-        hosts: ['item'],
-        cascadeDelete: 'descendants',
-    },
-    geometry: buildBlockGeometry,
-    geometryChildTypes: [],
-    geometryKey: (node) => JSON.stringify([node.topology, node.slots]),
-    floorplan: buildBlockFloorplan,
-    parametrics: blockParametrics,
-    affordanceTools: {
-        selection: () => import('./selection.js'),
-    },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Left click', label: 'Place block' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Block',
-        description: 'A topology-backed solid edited directly in the canvas.',
-        icon: { kind: 'url', src: '/icons/cube.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 75,
-        actionMenu: false,
-    },
-    mcp: {
-        description: 'An editable block solid with persistent vertex, edge, and face topology. Positions are level-local meters.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { blockEditContribution } from './definition.edit.js';
+import { blockRenderDefinition } from './definition.render.js';
+export const blockDefinition = composeNodeDefinition(blockRenderDefinition, blockEditContribution);
+export { blockBounds } from './definition.render.js';

package/dist/block/definition.render.d.ts

@@ -0,0 +1,11 @@
+import { type BlockNode as BlockNodeType } from '@pascal-app/core';
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { BlockNode } from './schema.js';
+export declare function blockBounds(node: BlockNodeType): {
+    size: [number, number, number];
+    center: [number, number, number];
+};
+export declare const blockRenderDefinition: NodeRenderDefinition<typeof BlockNode> & {
+    kind: 'block';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/block/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/block/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,IAAI,aAAa,EAGhC,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAoBpC,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa;UAMtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YACtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;EAalD;AAYD,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAAC,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAsE3F,CAAA"}

package/dist/block/definition.render.js

@@ -0,0 +1,120 @@
+import { blockSlots, createBoxBlockTopology, } from '@pascal-app/core';
+import { perNodeGeometryBatchable } from '../shared/node-batch/batchable.js';
+import { blockFaceHost } from './face-host.js';
+import { buildBlockGeometry } from './geometry.js';
+import { BlockNode } from './schema.js';
+import { blockSurfaceProvider } from './surface.js';
+/** Bottom within this of the floor (and top above it): the block stands on the floor. */
+const BLOCK_ON_FLOOR_MAX_BOTTOM = 0.1;
+const BLOCK_ON_FLOOR_MIN_TOP = 0.01;
+/**
+ * Floor collision is for blocks standing on the floor. Soffits, vaults,
+ * gutters and mantels hang above floor placements, and foundation pads sit
+ * under the floor, so neither blocks furniture nor gets refused when moved.
+ */
+function blockRestsOnFloor(node) {
+    const { size, center } = blockBounds(node);
+    const bottom = node.position[1] + center[1] - size[1] / 2;
+    const top = node.position[1] + center[1] + size[1] / 2;
+    return bottom <= BLOCK_ON_FLOOR_MAX_BOTTOM && top > BLOCK_ON_FLOOR_MIN_TOP;
+}
+export function blockBounds(node) {
+    const xs = node.topology.vertices.map((vertex) => vertex.position[0]);
+    const ys = node.topology.vertices.map((vertex) => vertex.position[1]);
+    const zs = node.topology.vertices.map((vertex) => vertex.position[2]);
+    if (xs.length === 0) {
+        return {
+            size: [0, 0, 0],
+            center: [0, 0, 0],
+        };
+    }
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minY = Math.min(...ys);
+    const maxY = Math.max(...ys);
+    const minZ = Math.min(...zs);
+    const maxZ = Math.max(...zs);
+    return {
+        size: [maxX - minX, maxY - minY, maxZ - minZ],
+        center: [(minX + maxX) / 2, (minY + maxY) / 2, (minZ + maxZ) / 2],
+    };
+}
+function footprintPosition(node, center) {
+    const cos = Math.cos(node.rotation);
+    const sin = Math.sin(node.rotation);
+    return [
+        node.position[0] + center[0] * cos + center[2] * sin,
+        node.position[1],
+        node.position[2] - center[0] * sin + center[2] * cos,
+    ];
+}
+export const blockRenderDefinition = {
+    kind: 'block',
+    schemaVersion: 5,
+    schema: BlockNode,
+    category: 'structure',
+    surfaceRole: 'wall',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+        position: [0, 0, 0],
+        rotation: 0,
+        topology: createBoxBlockTopology(),
+        slots: {},
+        slotNames: { body: 'Body' },
+    }),
+    capabilities: {
+        batchable: perNodeGeometryBatchable,
+        selectable: { hitVolume: 'bbox' },
+        surfaces: {
+            hosting: blockSurfaceProvider,
+            top: {
+                height: (rawNode) => {
+                    const node = rawNode;
+                    const { size, center } = blockBounds(node);
+                    return center[1] + size[1] / 2;
+                },
+            },
+            sides: { faces: 'all' },
+        },
+        movable: { axes: ['x', 'z'], gridSnap: true },
+        duplicable: { subtree: true },
+        deletable: true,
+        dragBounds: (rawNode) => blockBounds(rawNode),
+        floorPlaced: {
+            footprint: (rawNode) => {
+                const node = rawNode;
+                const { size, center } = blockBounds(node);
+                return {
+                    dimensions: size,
+                    position: footprintPosition(node, center),
+                    rotation: [0, node.rotation, 0],
+                };
+            },
+            collides: (rawNode) => blockRestsOnFloor(rawNode),
+        },
+        slots: (rawNode) => blockSlots(rawNode),
+        faceHost: blockFaceHost,
+    },
+    relations: {
+        hosts: ['item'],
+        cascadeDelete: 'descendants',
+    },
+    geometry: buildBlockGeometry,
+    geometryChildTypes: [],
+    geometryKey: (node) => JSON.stringify([node.topology, node.slots]),
+    presentation: {
+        label: 'Block',
+        description: 'A topology-backed solid edited directly in the canvas.',
+        icon: { kind: 'url', src: '/icons/cube.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 75,
+        actionMenu: false,
+    },
+    mcp: {
+        description: 'An editable block solid with persistent vertex, edge, and face topology. Positions are level-local meters.',
+    },
+};