@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/beam/definition.edit.js

@@ -0,0 +1,133 @@
+import { beamPlan, beamTopElevation, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, FLOORPLAN_NODE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { beamToolOptions } from './draft-settings.js';
+import { buildBeamFloorplan } from './floorplan.js';
+import { beamEndpointAffordance } from './floorplan-affordances.js';
+import { beamFloorplanMoveTarget } from './floorplan-move.js';
+import { beamPanelModel } from './panel-model.js';
+import { beamParametrics } from './parametrics.js';
+const SIDE_HANDLE_OFFSET = 0.22;
+const INCH = 0.0254;
+/** Where a beam's top is in the live scene (a descriptor may run before the scene has a level). */
+function topOf(beam, sceneApi) {
+    return beamTopElevation(sceneApi?.nodes() ?? {}, beam);
+}
+function midFrame(beam) {
+    const plan = beamPlan(beam);
+    return {
+        mid: [(plan.start[0] + plan.end[0]) / 2, (plan.start[1] + plan.end[1]) / 2],
+        normal: plan.normal,
+    };
+}
+/** The beam's top, as the elevation guides read a structural datum. */
+function guideSource(beam) {
+    const { mid } = midFrame(beam);
+    return { nodeId: beam.id, levelId: beam.parentId, anchor: mid };
+}
+// Side arrows: a tap hands the beam to its move tool, either side of its middle at mid-depth.
+function beamSideMoveHandle(side) {
+    return {
+        kind: 'tap-action',
+        onActivate: (node, _scene, editor) => editor.engageMove(node),
+        placement: {
+            position: (n, sceneApi) => {
+                const { mid, normal } = midFrame(n);
+                const offset = (n.width / 2 + SIDE_HANDLE_OFFSET) * side;
+                return [
+                    mid[0] + normal[0] * offset,
+                    topOf(n, sceneApi) - n.depth / 2,
+                    mid[1] + normal[1] * offset,
+                ];
+            },
+            rotationY: (n) => {
+                const { normal } = midFrame(n);
+                return Math.atan2(-normal[1] * side, normal[0] * side);
+            },
+        },
+        cursor: 'ew-resize',
+    };
+}
+// End pickers: a dashed leader down the beam's depth and a disc at its end; a tap drags the end.
+function beamEndPicker(endpoint) {
+    return {
+        kind: 'tap-action',
+        shape: 'corner-picker',
+        cursor: 'move',
+        nodeHeight: (n) => n.depth,
+        onActivate: (node, _scene, editor) => editor.engageEndpointMove(node, endpoint),
+        placement: {
+            position: (n, sceneApi) => {
+                const point = n[endpoint];
+                return [point[0], topOf(n, sceneApi) - n.depth, point[1]];
+            },
+        },
+    };
+}
+/**
+ * The beam's top, dragged up and down: it stores the top it lands on, caught by the levels'
+ * structural heights (a ceiling plane, a slab top) and otherwise to the half inch (the centimetre
+ * on a metric plan).
+ */
+function beamTopHandle(current) {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        currentValue: () => current,
+        magneticSnap: (n, value, sceneApi) => {
+            const snapped = resolveStructuralElevationSnap(guideSource(n), value, sceneApi.nodes());
+            if (snapped !== value)
+                return snapped;
+            const step = useViewer.getState().unit === 'imperial' ? INCH / 2 : 0.01;
+            return Math.round(value / step) * step;
+        },
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(guideSource(n), topOf(n, sceneApi), sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (_n, top) => ({ topElevation: top }),
+        placement: {
+            position: (n, sceneApi) => {
+                const { mid } = midFrame(n);
+                return [mid[0], topOf(n, sceneApi), mid[1]];
+            },
+        },
+    };
+}
+const beamHandles = (node, sceneApi) => [
+    beamSideMoveHandle(1),
+    beamSideMoveHandle(-1),
+    beamEndPicker('start'),
+    beamEndPicker('end'),
+    beamTopHandle(topOf(node, sceneApi)),
+];
+export const beamEditContribution = {
+    snapProfile: 'structural',
+    extensions: {
+        [FLOORPLAN_NODE_EXTENSION_KEY]: {
+            // In 2D-only view the 3D tool never mounts: the plan drafts beams itself.
+            tool: () => import('./tool.js').then((module) => ({ default: module.BeamFloorplanTool })),
+            // A beam crosses rooms: a plan click on it picks the beam, not the room.
+            planHitSelectsNode: true,
+        },
+        [PANEL_MODEL_EXTENSION]: beamPanelModel,
+    },
+    parametrics: beamParametrics,
+    handles: beamHandles,
+    tool: () => import('./tool.js'),
+    toolOptions: beamToolOptions,
+    toolHints: [
+        { key: 'Left click', label: 'Set beam start / end; the next beam starts there' },
+        { key: 'Alt', label: 'Free place' },
+        { key: 'Esc', label: 'End the run' },
+    ],
+    floorplan: buildBeamFloorplan,
+    floorplanMoveTarget: beamFloorplanMoveTarget,
+    floorplanAffordances: {
+        'move-endpoint': beamEndpointAffordance,
+    },
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+        'move-endpoint': () => import('./move-endpoint-tool.js'),
+    },
+};

package/dist/beam/definition.js

@@ -1,173 +1,4 @@
-import { beamPlan, beamTopElevation, } from '@pascal-app/core';
-import { clearStructuralElevationGuide, FLOORPLAN_NODE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
-import { useViewer } from '@pascal-app/viewer';
-import { beamToolOptions } from './draft-settings.js';
-import { buildBeamFloorplan } from './floorplan.js';
-import { beamEndpointAffordance } from './floorplan-affordances.js';
-import { beamFloorplanMoveTarget } from './floorplan-move.js';
-import { beamPanelModel } from './panel-model.js';
-import { beamParametrics } from './parametrics.js';
-import { BeamNode } from './schema.js';
-const SIDE_HANDLE_OFFSET = 0.22;
-const INCH = 0.0254;
-/** Where a beam's top is in the live scene (a descriptor may run before the scene has a level). */
-function topOf(beam, sceneApi) {
-    return beamTopElevation(sceneApi?.nodes() ?? {}, beam);
-}
-function midFrame(beam) {
-    const plan = beamPlan(beam);
-    return {
-        mid: [(plan.start[0] + plan.end[0]) / 2, (plan.start[1] + plan.end[1]) / 2],
-        normal: plan.normal,
-    };
-}
-/** The beam's top, as the elevation guides read a structural datum. */
-function guideSource(beam) {
-    const { mid } = midFrame(beam);
-    return { nodeId: beam.id, levelId: beam.parentId, anchor: mid };
-}
-// Side arrows: a tap hands the beam to its move tool, either side of its middle at mid-depth.
-function beamSideMoveHandle(side) {
-    return {
-        kind: 'tap-action',
-        onActivate: (node, _scene, editor) => editor.engageMove(node),
-        placement: {
-            position: (n, sceneApi) => {
-                const { mid, normal } = midFrame(n);
-                const offset = (n.width / 2 + SIDE_HANDLE_OFFSET) * side;
-                return [
-                    mid[0] + normal[0] * offset,
-                    topOf(n, sceneApi) - n.depth / 2,
-                    mid[1] + normal[1] * offset,
-                ];
-            },
-            rotationY: (n) => {
-                const { normal } = midFrame(n);
-                return Math.atan2(-normal[1] * side, normal[0] * side);
-            },
-        },
-        cursor: 'ew-resize',
-    };
-}
-// End pickers: a dashed leader down the beam's depth and a disc at its end; a tap drags the end.
-function beamEndPicker(endpoint) {
-    return {
-        kind: 'tap-action',
-        shape: 'corner-picker',
-        cursor: 'move',
-        nodeHeight: (n) => n.depth,
-        onActivate: (node, _scene, editor) => editor.engageEndpointMove(node, endpoint),
-        placement: {
-            position: (n, sceneApi) => {
-                const point = n[endpoint];
-                return [point[0], topOf(n, sceneApi) - n.depth, point[1]];
-            },
-        },
-    };
-}
-/**
- * The beam's top, dragged up and down: it stores the top it lands on, caught by the levels'
- * structural heights (a ceiling plane, a slab top) and otherwise to the half inch (the centimetre
- * on a metric plan).
- */
-function beamTopHandle(current) {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        shape: 'tracker',
-        currentValue: () => current,
-        magneticSnap: (n, value, sceneApi) => {
-            const snapped = resolveStructuralElevationSnap(guideSource(n), value, sceneApi.nodes());
-            if (snapped !== value)
-                return snapped;
-            const step = useViewer.getState().unit === 'imperial' ? INCH / 2 : 0.01;
-            return Math.round(value / step) * step;
-        },
-        onDrag: (n, sceneApi) => publishStructuralElevationGuide(guideSource(n), topOf(n, sceneApi), sceneApi.nodes()),
-        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
-        apply: (_n, top) => ({ topElevation: top }),
-        placement: {
-            position: (n, sceneApi) => {
-                const { mid } = midFrame(n);
-                return [mid[0], topOf(n, sceneApi), mid[1]];
-            },
-        },
-    };
-}
-const beamHandles = (node, sceneApi) => [
-    beamSideMoveHandle(1),
-    beamSideMoveHandle(-1),
-    beamEndPicker('start'),
-    beamEndPicker('end'),
-    beamTopHandle(topOf(node, sceneApi)),
-];
-/**
- * Beam — a horizontal framing member drawn by hand, end to end like a wall: a porch's header on
- * its posts, a deck's beam, a girder, a beam across an open span. A box of its actual section
- * along the centreline, its top stored or following the ceiling plane over it (`beamTopElevation`
- * in core); the plan draws it dashed with its size, as a framing plan does. `createBeam` in core
- * makes one from code.
- *
- * No `movable`: a beam has no `position`; it moves by both ends, through `affordanceTools.move` in
- * 3D and `floorplanMoveTarget` in the plan.
- */
-export const beamDefinition = {
-    kind: 'beam',
-    snapProfile: 'structural',
-    schemaVersion: 1,
-    schema: BeamNode,
-    category: 'structure',
-    extensions: {
-        [FLOORPLAN_NODE_EXTENSION_KEY]: {
-            // In 2D-only view the 3D tool never mounts: the plan drafts beams itself.
-            tool: () => import('./tool.js').then((module) => ({ default: module.BeamFloorplanTool })),
-            // A beam crosses rooms: a plan click on it picks the beam, not the room.
-            planHitSelectsNode: true,
-        },
-        [PANEL_MODEL_EXTENSION]: beamPanelModel,
-    },
-    defaults: () => {
-        const { id: _id, type: _type, ...rest } = BeamNode.parse({ start: [0, 0], end: [3, 0] });
-        return rest;
-    },
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        surfaces: { hosting: false },
-        duplicable: true,
-        deletable: true,
-        drawTool: true,
-    },
-    // The renderer reads the scene and live overrides itself; nothing consumes a dirty mark.
-    dirtyTracking: false,
-    rendersChildren: false,
-    renderer: { kind: 'parametric', module: () => import('./renderer.js') },
-    parametrics: beamParametrics,
-    handles: beamHandles,
-    tool: () => import('./tool.js'),
-    toolOptions: beamToolOptions,
-    toolHints: [
-        { key: 'Left click', label: 'Set beam start / end; the next beam starts there' },
-        { key: 'Alt', label: 'Free place' },
-        { key: 'Esc', label: 'End the run' },
-    ],
-    floorplan: buildBeamFloorplan,
-    floorplanMoveTarget: beamFloorplanMoveTarget,
-    floorplanAffordances: {
-        'move-endpoint': beamEndpointAffordance,
-    },
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-        'move-endpoint': () => import('./move-endpoint-tool.js'),
-    },
-    presentation: {
-        label: 'Beam',
-        description: 'A framing beam drawn end to end: a porch header, a deck beam, a girder.',
-        icon: { kind: 'url', src: '/icons/beam.svg' },
-        paletteSection: 'structure',
-        paletteOrder: 72,
-    },
-    mcp: {
-        description: 'A horizontal framing beam: start/end centreline (level-local), actual width/depth, nominal size and plies, material, dropped or flush placement, and a top elevation (absent = under the ceiling plane).',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { beamEditContribution } from './definition.edit.js';
+import { beamRenderDefinition } from './definition.render.js';
+export const beamDefinition = composeNodeDefinition(beamRenderDefinition, beamEditContribution);

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

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { BeamNode } from './schema.js';
+export declare const beamRenderDefinition: NodeRenderDefinition<typeof BeamNode> & {
+    kind: 'beam';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/beam/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CA+BxF,CAAA"}

package/dist/beam/definition.render.js

@@ -0,0 +1,32 @@
+import { BeamNode } from './schema.js';
+export const beamRenderDefinition = {
+    kind: 'beam',
+    schemaVersion: 1,
+    schema: BeamNode,
+    category: 'structure',
+    defaults: () => {
+        const { id: _id, type: _type, ...rest } = BeamNode.parse({ start: [0, 0], end: [3, 0] });
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        surfaces: { hosting: false },
+        duplicable: true,
+        deletable: true,
+        drawTool: true,
+    },
+    // The renderer reads the scene and live overrides itself; nothing consumes a dirty mark.
+    dirtyTracking: false,
+    rendersChildren: false,
+    renderer: { kind: 'parametric', module: () => import('./renderer.js') },
+    presentation: {
+        label: 'Beam',
+        description: 'A framing beam drawn end to end: a porch header, a deck beam, a girder.',
+        icon: { kind: 'url', src: '/icons/beam.svg' },
+        paletteSection: 'structure',
+        paletteOrder: 72,
+    },
+    mcp: {
+        description: 'A horizontal framing beam: start/end centreline (level-local), actual width/depth, nominal size and plies, material, dropped or flush placement, and a top elevation (absent = under the ceiling plane).',
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/beam/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAIb,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAazB,MAAM,MAAM,mBAAmB,GAAG;IAAE,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAAE,CAAA;AAE/D;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAoFjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/beam/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAIb,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AASzB,MAAM,MAAM,mBAAmB,GAAG;IAAE,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAAE,CAAA;AAE/D;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAoFjG"}

package/dist/beam/floorplan.js

@@ -1,5 +1,5 @@
-import { beamOutline, beamPlan, beamSizeLabel, } from '@pascal-app/core';
-import { floorplanGeometryMetadata, formatLinearMeasurement, readFloorplanMetricNotationOverride, } from '@pascal-app/editor';
+import { beamOutline, beamPlan, beamSizeLabel, formatLinearMeasurement, } from '@pascal-app/core';
+import { floorplanGeometryMetadata, readFloorplanMetricNotationOverride } from '@pascal-app/editor';
 /** Hidden work: a beam is over the plan's cut, so it is drawn dashed, as a framing plan draws it. */
 const HIDDEN_DASH = '8 4';
 const MOVE_ARROW_OFFSET = 0.17;

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/beam/panel.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,QAAQ,EAYd,MAAM,kBAAkB,CAAA;AA4DzB,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM;;;EAEpF;AAED;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,uCA4KhC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/beam/panel.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,QAAQ,EAad,MAAM,kBAAkB,CAAA;AA2DzB,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM;;;EAEpF;AAED;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,uCA4KhC"}

package/dist/beam/panel.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { beamCeilingPlane, beamPlan, beamSizeLabel, beamSizePresetPatch, beamTopElevation, beamTopReferencePatch, DEFAULT_FRAMING_POST_SIZE, usePascalI18n, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, formatLinearMeasurement, MetricControl, PanelSection, PanelWrapper, SegmentedControl, SelectControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { beamCeilingPlane, beamPlan, beamSizeLabel, beamSizePresetPatch, beamTopElevation, beamTopReferencePatch, DEFAULT_FRAMING_POST_SIZE, formatLinearMeasurement, usePascalI18n, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, MetricControl, PanelSection, PanelWrapper, SegmentedControl, SelectControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Columns2, Move, Trash2 } from 'lucide-react';
 import { useState } from 'react';

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/beam/tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,QAAQ,EAOd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAOL,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"}
+{"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

@@ -1,7 +1,7 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { beamPlan, beamTopElevation, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
-import { CursorSphere, DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, formatLinearMeasurement, isSegmentLongEnough, markToolCancelConsumed, triggerSFX, useEditor, usePlacementPreview, useWallSnapIndicator, visibleScene, } from '@pascal-app/editor';
+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';

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' },
+    ],
+};