@pascal-app/nodes 1.0.0-beta.5 → 1.0.0

package/dist/block/slots.d.ts

@@ -0,0 +1,4 @@
+import type { BlockNode, SlotDeclaration } from '@pascal-app/core';
+export declare const BLOCK_SLOT_ID = "body";
+export declare function blockSlots(node: BlockNode): SlotDeclaration[];
+//# sourceMappingURL=slots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/block/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGlE,eAAO,MAAM,aAAa,SAAqB,CAAA;AAW/C,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,EAAE,CAK7D"}

package/dist/block/slots.js

@@ -0,0 +1,17 @@
+import { BLOCK_BODY_SLOT_ID, blockMaterialSlotIds } from './material-slots';
+export const BLOCK_SLOT_ID = BLOCK_BODY_SLOT_ID;
+function slotLabel(slotId) {
+    if (slotId === BLOCK_SLOT_ID)
+        return 'Body';
+    return slotId
+        .split('-')
+        .filter(Boolean)
+        .map((part) => `${part[0]?.toUpperCase() ?? ''}${part.slice(1)}`)
+        .join(' ');
+}
+export function blockSlots(node) {
+    return blockMaterialSlotIds(node.topology, node.slots, node.slotNames).map((slotId) => ({
+        slotId,
+        label: node.slotNames?.[slotId]?.trim() || slotLabel(slotId),
+    }));
+}

package/dist/block/tool.d.ts

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

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

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

package/dist/block/tool.js

@@ -0,0 +1,174 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BlockNode, collectAlignmentAnchors, emitter, resolveFrozenFloorPlacementPatch, resolveSupportSlabPatch, useSpatialQuery, } from '@pascal-app/core';
+import { getFloorStackPreviewPosition, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, movementSfxStepKey, resolvePointerSupportSurface, triggerSFX, useAlignmentGuides, useEditor, useInteractionScope, useRegistryToolContext, } from '@pascal-app/editor';
+import { useThree } from '@react-three/fiber';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { getLevelLocalSnappedPosition, isForcePlacementEvent, resolveAlignedFloorPlacement, stopPlacementCommitPropagation, subscribeFloorPlacementClicks, } from '../shared/floor-placement';
+import { blockBounds, blockDefinition } from './definition';
+import BlockPreview from './preview';
+const BlockTool = () => {
+    const { activeLevelId, sceneApi, selectNode } = useRegistryToolContext();
+    const { canPlaceOnFloor } = useSpatialQuery();
+    const camera = useThree((state) => state.camera);
+    const cameraRef = useRef(camera);
+    cameraRef.current = camera;
+    const cursorRef = useRef(null);
+    const supportSurfaceRef = useRef(null);
+    const previousSnapRef = useRef(null);
+    const cursorVisibleRef = useRef(false);
+    const [cursorVisible, setCursorVisible] = useState(false);
+    const [validPlacement, setValidPlacement] = useState(true);
+    const previewNode = useMemo(() => BlockNode.parse({
+        ...blockDefinition.defaults(),
+        name: 'Block',
+        position: [0, 0, 0],
+    }), []);
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        let lastPosition = null;
+        let alignmentCandidates = collectAlignmentAnchors(sceneApi.nodes(), previewNode.id);
+        const { size } = blockBounds(previewNode);
+        useInteractionScope.getState().begin({
+            kind: 'placing',
+            node: BlockNode.parse({
+                ...previewNode,
+                parentId: activeLevelId,
+                metadata: { isNew: true },
+            }),
+            nodeId: previewNode.id,
+            nodeType: previewNode.type,
+            view: '3d',
+            pressDrag: false,
+            driver: 'registry-tool',
+        });
+        const pointedSurfaceFor = (event) => typeof HTMLCanvasElement !== 'undefined' &&
+            event.nativeEvent?.target instanceof HTMLCanvasElement
+            ? resolvePointerSupportSurface(cameraRef.current, event.position, {
+                includeNodeTopSurfaces: true,
+            })
+            : null;
+        const resolvePlacement = (position, surface) => {
+            const draftNode = BlockNode.parse({
+                ...blockDefinition.defaults(),
+                name: 'Block',
+                parentId: activeLevelId,
+                position,
+            });
+            const nodes = { ...sceneApi.nodes(), [draftNode.id]: draftNode };
+            const patch = surface?.sourceNodeId
+                ? resolveFrozenFloorPlacementPatch(draftNode, nodes, {
+                    position,
+                    rotation: draftNode.rotation,
+                    elevation: surface.elevation,
+                    preferredSlabId: surface.supportSlabId,
+                })
+                : {
+                    position,
+                    ...resolveSupportSlabPatch(draftNode, nodes, {
+                        maxElevation: surface?.elevation,
+                        pinSupport: true,
+                    }),
+                };
+            return { draftNode, patch };
+        };
+        const onGridMove = (event) => {
+            if (!cursorVisibleRef.current) {
+                cursorVisibleRef.current = true;
+                setCursorVisible(true);
+            }
+            const forcePlacement = isForcePlacementEvent(event);
+            const pointed = pointedSurfaceFor(event);
+            supportSurfaceRef.current = pointed;
+            const gridSnapActive = isGridSnapActive();
+            const { position, guides } = resolveAlignedFloorPlacement({
+                node: previewNode,
+                rawX: pointed?.localPoint?.[0] ?? event.localPosition[0],
+                rawZ: pointed?.localPoint?.[2] ?? event.localPosition[2],
+                gridStep: useEditor.getState().gridSnapStep,
+                candidates: alignmentCandidates,
+                showAlignment: isAlignmentGuideActive(),
+                applyAlignmentSnap: isMagneticSnapActive(),
+                bypassGrid: !gridSnapActive,
+            });
+            useAlignmentGuides.getState().set(guides);
+            const { patch } = resolvePlacement(position, pointed);
+            const resolvedPosition = patch.position;
+            const visualPosition = getFloorStackPreviewPosition({
+                node: { ...previewNode, ...patch },
+                position: resolvedPosition,
+                rotation: previewNode.rotation,
+                levelId: activeLevelId,
+                maxElevation: pointed?.sourceNodeId ? null : pointed?.elevation,
+            });
+            cursorRef.current?.position.set(...visualPosition);
+            lastPosition = resolvedPosition;
+            const placement = canPlaceOnFloor(activeLevelId, resolvedPosition, size, [
+                0,
+                previewNode.rotation,
+                0,
+            ]);
+            setValidPlacement(forcePlacement || placement.valid);
+            const snapKey = movementSfxStepKey({
+                coords: [resolvedPosition[0], resolvedPosition[2]],
+                gridSnapActive,
+                gridStep: useEditor.getState().gridSnapStep,
+            });
+            if (snapKey !== previousSnapRef.current) {
+                triggerSFX('sfx:grid-snap');
+                previousSnapRef.current = snapKey;
+            }
+        };
+        const commit = (event) => {
+            const forcePlacement = isForcePlacementEvent(event);
+            const pointed = pointedSurfaceFor(event) ?? supportSurfaceRef.current;
+            supportSurfaceRef.current = pointed;
+            const fallbackPosition = lastPosition ??
+                getLevelLocalSnappedPosition(activeLevelId, event, useEditor.getState().gridSnapStep, !isGridSnapActive());
+            const position = [fallbackPosition[0], 0, fallbackPosition[2]];
+            const { draftNode, patch } = resolvePlacement(position, pointed);
+            const placement = canPlaceOnFloor(activeLevelId, patch.position, size, [
+                0,
+                draftNode.rotation,
+                0,
+            ]);
+            setValidPlacement(forcePlacement || placement.valid);
+            if (!(forcePlacement || placement.valid)) {
+                stopPlacementCommitPropagation(event);
+                return;
+            }
+            const node = BlockNode.parse({
+                ...draftNode,
+                ...patch,
+            });
+            sceneApi.upsert(node, activeLevelId);
+            selectNode(node.id);
+            triggerSFX('sfx:structure-build');
+            useAlignmentGuides.getState().clear();
+            if (useEditor.getState().getContinuation('point') === 'repeat') {
+                alignmentCandidates = collectAlignmentAnchors(sceneApi.nodes(), previewNode.id);
+            }
+            else {
+                cursorVisibleRef.current = false;
+                setCursorVisible(false);
+                useEditor.getState().setTool(null);
+            }
+            stopPlacementCommitPropagation(event);
+        };
+        emitter.on('grid:move', onGridMove);
+        const unsubscribe = subscribeFloorPlacementClicks(commit);
+        return () => {
+            emitter.off('grid:move', onGridMove);
+            unsubscribe();
+            useAlignmentGuides.getState().clear();
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'placing' && scope.nodeId === previewNode.id);
+        };
+    }, [activeLevelId, canPlaceOnFloor, previewNode, sceneApi, selectNode]);
+    if (!activeLevelId)
+        return null;
+    return (_jsx("group", { ref: cursorRef, visible: cursorVisible, children: _jsx(BlockPreview, { node: previewNode, valid: validPlacement }) }));
+};
+export default BlockTool;

package/dist/block/toolbar-state.d.ts

@@ -0,0 +1,46 @@
+export type BlockToolbarMode = 'vertex' | 'edge' | 'face';
+export type BlockScaleAxis = 'uniform' | 'x' | 'y' | 'z';
+export type BlockTransformTool = 'transform' | 'loop-cut' | 'bevel';
+export type BlockOperationAvailability = {
+    extrude: boolean;
+    inset: boolean;
+    merge: boolean;
+    dissolve: boolean;
+    bevel: boolean;
+};
+export type BlockGizmoDimensions = {
+    length: number;
+    radius: number;
+    rotationRadius: number;
+    planeHandleSize: number;
+    planeHandleOffset: number;
+};
+export type BlockGizmoHitDimensions = {
+    axisRadius: number;
+    scaleRadius: number;
+    planeSize: number;
+    rotationTube: number;
+    rotationArc: number;
+    rotationStart: number;
+};
+export declare function blockOperationAvailability(mode: BlockToolbarMode, selectedCount: number): BlockOperationAvailability;
+export declare function formatBlockSelectionStatus(mode: BlockToolbarMode, selectedCount: number): string;
+export declare function blockComponentStatus({ mode, selectedCount, tool, loopCutCount, loopCutFactor, bevelSegments, bevelWidth, }: {
+    mode: BlockToolbarMode;
+    selectedCount: number;
+    tool: BlockTransformTool;
+    loopCutCount: number;
+    loopCutFactor: number;
+    bevelSegments: number;
+    bevelWidth: number;
+}): string | null;
+export declare function blockScaleFactors(axis: BlockScaleAxis, factor: number): [number, number, number];
+export declare function blockScaleFactorFromDrag(distance: number, handleLength: number, snapStep?: number): number;
+export declare function blockGizmoDimensions(_topologyExtent: number): BlockGizmoDimensions;
+export declare function blockGizmoHitDimensions(radius: number, planeHandleSize: number): BlockGizmoHitDimensions;
+export declare function blockToolbarOffset(topologyExtent: number, gizmoLength: number): number;
+export declare function blockBevelWidthFromDrag(deltaX: number, deltaY: number, { topologyExtent, projectedExtentPixels, }: {
+    topologyExtent: number;
+    projectedExtentPixels: number;
+}): number;
+//# sourceMappingURL=toolbar-state.d.ts.map

package/dist/block/toolbar-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-state.d.ts","sourceRoot":"","sources":["../../src/block/toolbar-state.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;AACzD,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;AACxD,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG,UAAU,GAAG,OAAO,CAAA;AAEnE,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAUD,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,aAAa,EAAE,MAAM,GACpB,0BAA0B,CAQ5B;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAGhG;AAED,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,aAAa,EACb,IAAI,EACJ,YAAY,EACZ,aAAa,EACb,aAAa,EACb,UAAU,GACX,EAAE;IACD,IAAI,EAAE,gBAAgB,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,kBAAkB,CAAA;IACxB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;CACnB,GAAG,MAAM,GAAG,IAAI,CAShB;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAGhG;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,QAAQ,SAAI,GACX,MAAM,CAOR;AAED,wBAAgB,oBAAoB,CAAC,eAAe,EAAE,MAAM,GAAG,oBAAoB,CAElF;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,GACtB,uBAAuB,CAUzB;AAED,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAItF;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,EACE,cAAc,EACd,qBAAqB,GACtB,EAAE;IACD,cAAc,EAAE,MAAM,CAAA;IACtB,qBAAqB,EAAE,MAAM,CAAA;CAC9B,GACA,MAAM,CAIR"}

package/dist/block/toolbar-state.js

@@ -0,0 +1,67 @@
+const FIXED_BLOCK_GIZMO_DIMENSIONS = {
+    length: 0.7,
+    radius: 0.022,
+    rotationRadius: 0.455,
+    planeHandleSize: 0.14,
+    planeHandleOffset: 0.175,
+};
+export function blockOperationAvailability(mode, selectedCount) {
+    return {
+        extrude: mode === 'face' && selectedCount >= 1,
+        inset: mode === 'face' && selectedCount >= 1,
+        merge: mode === 'vertex' && selectedCount >= 2,
+        dissolve: (mode === 'edge' && selectedCount >= 1) || (mode === 'face' && selectedCount >= 2),
+        bevel: mode === 'edge',
+    };
+}
+export function formatBlockSelectionStatus(mode, selectedCount) {
+    const label = selectedCount === 1 ? mode : mode === 'vertex' ? 'vertices' : `${mode}s`;
+    return `${selectedCount} ${label}`.toUpperCase();
+}
+export function blockComponentStatus({ mode, selectedCount, tool, loopCutCount, loopCutFactor, bevelSegments, bevelWidth, }) {
+    if (tool === 'loop-cut') {
+        return `Loop Cut · ${loopCutCount} cut${loopCutCount === 1 ? '' : 's'} · factor ${loopCutFactor.toFixed(2)} · click or drag an edge · release applies · wheel changes count`;
+    }
+    if (tool === 'bevel') {
+        const width = String(Math.round(bevelWidth * 1000) / 1000);
+        return `Bevel · width ${width} m · ${bevelSegments} segments · drag changes width · wheel changes segments`;
+    }
+    return selectedCount === 0 ? `Click a ${mode} to select it` : null;
+}
+export function blockScaleFactors(axis, factor) {
+    if (axis === 'uniform')
+        return [factor, factor, factor];
+    return [axis === 'x' ? factor : 1, axis === 'y' ? factor : 1, axis === 'z' ? factor : 1];
+}
+export function blockScaleFactorFromDrag(distance, handleLength, snapStep = 0) {
+    const safeLength = Math.max(Math.abs(handleLength), 1e-6);
+    let factor = 1 + distance / safeLength;
+    if (Number.isFinite(snapStep) && snapStep > 0) {
+        factor = Math.round(factor / snapStep) * snapStep;
+    }
+    return Math.max(0.01, factor);
+}
+export function blockGizmoDimensions(_topologyExtent) {
+    return FIXED_BLOCK_GIZMO_DIMENSIONS;
+}
+export function blockGizmoHitDimensions(radius, planeHandleSize) {
+    const rotationStart = Math.PI / 15;
+    return {
+        axisRadius: radius * 3,
+        scaleRadius: radius * 3.2,
+        planeSize: planeHandleSize * 1.1,
+        rotationTube: radius * 1.5,
+        rotationArc: Math.PI / 2 - rotationStart * 2,
+        rotationStart,
+    };
+}
+export function blockToolbarOffset(topologyExtent, gizmoLength) {
+    const meshRelativeOffset = Math.min(1.4, Math.max(0.9, topologyExtent * 0.25));
+    const scaleHandleReach = gizmoLength * 1.2;
+    return Math.max(meshRelativeOffset, scaleHandleReach + 0.31);
+}
+export function blockBevelWidthFromDrag(deltaX, deltaY, { topologyExtent, projectedExtentPixels, }) {
+    const safeExtent = Math.max(Math.abs(topologyExtent), 0.001);
+    const safeProjectedExtent = Math.max(Math.abs(projectedExtentPixels), 1);
+    return (Math.hypot(deltaX, deltaY) * safeExtent) / safeProjectedExtent;
+}

package/dist/block/use-block-face-operation.d.ts

@@ -0,0 +1,39 @@
+import { type AnyNodeId, type BlockTopology, type SceneApi } from '@pascal-app/core';
+import { type SelectionAffordanceProps } from '@pascal-app/editor';
+import { type Dispatch, type MutableRefObject, type SetStateAction } from 'react';
+import type { Camera, Object3D } from 'three';
+import { Vector2 } from 'three';
+import { type BlockCommand, type BlockSelection } from './commands';
+import type { BlockSfxAction } from './interaction-sfx';
+import { type BlockExtrudeAxis, type BlockModalFaceOperation } from './modal-face-operation';
+import { type BlockModalFeedbackMode } from './modal-transform';
+type StateSetter<T> = Dispatch<SetStateAction<T>>;
+export type UseBlockFaceOperationOptions = {
+    beginInputDrag: SelectionAffordanceProps['interactionApi']['beginInputDrag'];
+    camera: Camera;
+    cancelRef: MutableRefObject<(() => void) | null>;
+    canvas: HTMLCanvasElement;
+    closeToolbar: () => void;
+    commit: (baseTopology: BlockTopology, command: BlockCommand, label: string) => boolean;
+    displayTopology: BlockTopology;
+    extent: number;
+    lastPointerClientRef: MutableRefObject<Vector2 | null>;
+    mode: BlockSelection['mode'];
+    nodeId: AnyNodeId;
+    ownsEditSession: () => boolean;
+    playSfx: (action: BlockSfxAction) => void;
+    sceneApi: Pick<SceneApi, 'markDirty'>;
+    selectedIds: string[];
+    selection: BlockSelection;
+    setActiveFaceOperation: StateSetter<BlockModalFaceOperation | null>;
+    setError: StateSetter<string | null>;
+    setFaceOperationAxis: StateSetter<BlockExtrudeAxis>;
+    setFaceOperationValue: StateSetter<string>;
+    setModalFeedbackMode: StateSetter<BlockModalFeedbackMode>;
+    setPreviewTopology: StateSetter<BlockTopology | null>;
+    setTransformNumericInput: StateSetter<string>;
+    target: Object3D;
+};
+export declare function useBlockFaceOperation({ beginInputDrag, camera, cancelRef, canvas, closeToolbar, commit, displayTopology, extent, lastPointerClientRef, mode, nodeId, ownsEditSession, playSfx, sceneApi, selectedIds, selection, setActiveFaceOperation, setError, setFaceOperationAxis, setFaceOperationValue, setModalFeedbackMode, setPreviewTopology, setTransformNumericInput, target, }: UseBlockFaceOperationOptions): (operation: BlockModalFaceOperation) => boolean;
+export {};
+//# sourceMappingURL=use-block-face-operation.d.ts.map

package/dist/block/use-block-face-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-block-face-operation.d.ts","sourceRoot":"","sources":["../../src/block/use-block-face-operation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAe,MAAM,OAAO,CAAA;AAC9F,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAC7C,OAAO,EAAE,OAAO,EAAW,MAAM,OAAO,CAAA;AACxC,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,cAAc,EAEpB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAG7B,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EACL,KAAK,sBAAsB,EAK5B,MAAM,mBAAmB,CAAA;AAO1B,KAAK,WAAW,CAAC,CAAC,IAAI,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;AAEjD,MAAM,MAAM,4BAA4B,GAAG;IACzC,cAAc,EAAE,wBAAwB,CAAC,gBAAgB,CAAC,CAAC,gBAAgB,CAAC,CAAA;IAC5E,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,gBAAgB,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,CAAA;IAChD,MAAM,EAAE,iBAAiB,CAAA;IACzB,YAAY,EAAE,MAAM,IAAI,CAAA;IACxB,MAAM,EAAE,CAAC,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;IACtF,eAAe,EAAE,aAAa,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,oBAAoB,EAAE,gBAAgB,CAAC,OAAO,GAAG,IAAI,CAAC,CAAA;IACtD,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAA;IAC5B,MAAM,EAAE,SAAS,CAAA;IACjB,eAAe,EAAE,MAAM,OAAO,CAAA;IAC9B,OAAO,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAA;IACzC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAA;IACrC,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,SAAS,EAAE,cAAc,CAAA;IACzB,sBAAsB,EAAE,WAAW,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAA;IACnE,QAAQ,EAAE,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IACpC,oBAAoB,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAA;IACnD,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC1C,oBAAoB,EAAE,WAAW,CAAC,sBAAsB,CAAC,CAAA;IACzD,kBAAkB,EAAE,WAAW,CAAC,aAAa,GAAG,IAAI,CAAC,CAAA;IACrD,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC7C,MAAM,EAAE,QAAQ,CAAA;CACjB,CAAA;AAED,wBAAgB,qBAAqB,CAAC,EACpC,cAAc,EACd,MAAM,EACN,SAAS,EACT,MAAM,EACN,YAAY,EACZ,MAAM,EACN,eAAe,EACf,MAAM,EACN,oBAAoB,EACpB,IAAI,EACJ,MAAM,EACN,eAAe,EACf,OAAO,EACP,QAAQ,EACR,WAAW,EACX,SAAS,EACT,sBAAsB,EACtB,QAAQ,EACR,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,EACxB,MAAM,GACP,EAAE,4BAA4B,eAEf,uBAAuB,aAwOtC"}

package/dist/block/use-block-face-operation.js

@@ -0,0 +1,218 @@
+import { useLiveNodeOverrides, } from '@pascal-app/core';
+import { isGridSnapActive, meshEditScope, swallowNextClick, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { useCallback } from 'react';
+import { Vector2, Vector3 } from 'three';
+import { applyBlockCommand, blockFaceNormal, } from './commands';
+import { blockFaceOperationCommand, blockFaceOperationValueFromPointer, } from './modal-face-operation';
+import { beginBlockModalSession } from './modal-session';
+import { blockPointerDistanceForAxis, blockTransformAxisFromKey, blockTransformNumericInputFromKey, blockTransformNumericValue, } from './modal-transform';
+import { blockLocalPointToClient, blockSelectionCentroid, blockTopologyClientExtent, } from './selection-geometry';
+export function useBlockFaceOperation({ beginInputDrag, camera, cancelRef, canvas, closeToolbar, commit, displayTopology, extent, lastPointerClientRef, mode, nodeId, ownsEditSession, playSfx, sceneApi, selectedIds, selection, setActiveFaceOperation, setError, setFaceOperationAxis, setFaceOperationValue, setModalFeedbackMode, setPreviewTopology, setTransformNumericInput, target, }) {
+    return useCallback((operation) => {
+        if (!ownsEditSession() || mode !== 'face' || selectedIds.length === 0 || cancelRef.current) {
+            return false;
+        }
+        const faceIds = [...selectedIds];
+        if (faceIds.some((id) => !displayTopology.faces.some((face) => face.id === id)))
+            return false;
+        const origin = blockSelectionCentroid(displayTopology, selection);
+        if (!origin)
+            return false;
+        const pivotClient = blockLocalPointToClient(origin, target, camera, canvas);
+        if (!pivotClient)
+            return false;
+        const projectedExtent = blockTopologyClientExtent(displayTopology, target, camera, canvas);
+        if (!projectedExtent)
+            return false;
+        const selectedFaceNormal = faceIds.reduce((sum, id) => {
+            const face = displayTopology.faces.find((candidate) => candidate.id === id);
+            const normal = blockFaceNormal(displayTopology, face);
+            return normal ? sum.add(new Vector3(...normal)) : sum;
+        }, new Vector3());
+        if (selectedFaceNormal.lengthSq() > 1e-12)
+            selectedFaceNormal.normalize();
+        const projectedExtrusionDirection = (axis) => {
+            const direction = axis === 'normal'
+                ? selectedFaceNormal
+                : new Vector3(axis === 'x' ? 1 : 0, axis === 'y' ? 1 : 0, axis === 'z' ? 1 : 0);
+            if (direction.lengthSq() <= 1e-12)
+                return null;
+            const endpointClient = blockLocalPointToClient([
+                origin[0] + direction.x * 0.1,
+                origin[1] + direction.y * 0.1,
+                origin[2] + direction.z * 0.1,
+            ], target, camera, canvas);
+            return endpointClient?.sub(pivotClient) ?? null;
+        };
+        const startPointer = lastPointerClientRef.current?.clone() ?? pivotClient.clone().add(new Vector2(80, 0));
+        const baseTopology = displayTopology;
+        let latestTopology = null;
+        let latestSelection = null;
+        let latestValue = 0;
+        let typedInput = '';
+        let lastClientX = startPointer.x;
+        let lastClientY = startPointer.y;
+        let lastAltKey = false;
+        let lastSnapValue = null;
+        let extrudeAxis = 'normal';
+        let extrusionDirection = projectedExtrusionDirection(extrudeAxis);
+        const updatePreview = (clientX, clientY, altKey) => {
+            lastClientX = clientX;
+            lastClientY = clientY;
+            lastAltKey = altKey;
+            const typedValue = blockTransformNumericValue(typedInput, operation === 'extrude' ? 'translate' : 'scale');
+            let value = typedValue ??
+                blockFaceOperationValueFromPointer(operation, startPointer, { x: clientX, y: clientY }, pivotClient, extent, projectedExtent, extrusionDirection);
+            if (typedValue === null && operation === 'extrude' && extrudeAxis !== 'normal') {
+                value = blockPointerDistanceForAxis(extrudeAxis, value);
+            }
+            const snapping = operation === 'extrude' && typedValue === null && isGridSnapActive() && !altKey;
+            if (snapping) {
+                const step = useEditor.getState().gridSnapStep;
+                if (step > 0)
+                    value = Math.round(value / step) * step;
+            }
+            setFaceOperationValue(typedInput || String(Math.round(value * 1000) / 1000));
+            setModalFeedbackMode(typedInput ? 'exact' : snapping ? 'grid' : 'free');
+            if (Math.abs(value) <= 1e-6) {
+                latestTopology = null;
+                latestSelection = null;
+                latestValue = 0;
+                setPreviewTopology(null);
+                useLiveNodeOverrides.getState().clear(nodeId);
+                sceneApi.markDirty(nodeId);
+                return;
+            }
+            if (snapping && value !== lastSnapValue) {
+                lastSnapValue = value;
+                playSfx('move-step');
+            }
+            else if (!snapping) {
+                lastSnapValue = null;
+            }
+            const result = applyBlockCommand(baseTopology, blockFaceOperationCommand(operation, faceIds, value, extrudeAxis));
+            if (!result.ok) {
+                setError(result.error);
+                return;
+            }
+            latestTopology = result.topology;
+            latestSelection = result.selection;
+            latestValue = value;
+            setPreviewTopology(result.topology);
+            useLiveNodeOverrides.getState().set(nodeId, { topology: result.topology });
+            sceneApi.markDirty(nodeId);
+            setError(null);
+        };
+        const complete = (commitOperation) => {
+            useLiveNodeOverrides.getState().clear(nodeId);
+            sceneApi.markDirty(nodeId);
+            setPreviewTopology(null);
+            setActiveFaceOperation(null);
+            setFaceOperationAxis('normal');
+            setFaceOperationValue('');
+            setTransformNumericInput('');
+            setModalFeedbackMode('free');
+            if (commitOperation && latestTopology && latestSelection && Math.abs(latestValue) > 1e-6) {
+                commit(baseTopology, blockFaceOperationCommand(operation, faceIds, latestValue, extrudeAxis), operation === 'extrude' ? 'Extrude' : 'Inset');
+                playSfx('operation-commit');
+            }
+            else if (!commitOperation) {
+                playSfx('cancel');
+            }
+            if (ownsEditSession())
+                useInteractionScope.getState().begin(meshEditScope(nodeId));
+            swallowNextClick();
+        };
+        const onMove = (pointerEvent) => {
+            lastPointerClientRef.current = new Vector2(pointerEvent.clientX, pointerEvent.clientY);
+            updatePreview(pointerEvent.clientX, pointerEvent.clientY, pointerEvent.altKey);
+        };
+        const onPointerDown = (pointerEvent, finish) => {
+            if (pointerEvent.button !== 0 && pointerEvent.button !== 2)
+                return;
+            pointerEvent.preventDefault();
+            pointerEvent.stopImmediatePropagation();
+            finish(pointerEvent.button === 0);
+        };
+        const onKeyDown = (keyboardEvent, finish) => {
+            const element = keyboardEvent.target;
+            if (element?.tagName === 'INPUT' ||
+                element?.tagName === 'TEXTAREA' ||
+                element?.isContentEditable) {
+                return;
+            }
+            const nextAxis = operation === 'extrude' ? blockTransformAxisFromKey(keyboardEvent.key) : null;
+            const nextInput = blockTransformNumericInputFromKey(typedInput, keyboardEvent.key);
+            if (nextAxis) {
+                keyboardEvent.preventDefault();
+                keyboardEvent.stopImmediatePropagation();
+                extrudeAxis = nextAxis;
+                extrusionDirection = projectedExtrusionDirection(nextAxis);
+                setFaceOperationAxis(nextAxis);
+                lastSnapValue = null;
+                updatePreview(lastClientX, lastClientY, lastAltKey);
+            }
+            else if (nextInput !== null) {
+                keyboardEvent.preventDefault();
+                keyboardEvent.stopImmediatePropagation();
+                typedInput = nextInput;
+                setTransformNumericInput(nextInput);
+                updatePreview(lastClientX, lastClientY, lastAltKey);
+            }
+            else if (keyboardEvent.key === 'Enter') {
+                keyboardEvent.preventDefault();
+                keyboardEvent.stopImmediatePropagation();
+                finish(true);
+            }
+            else if (keyboardEvent.key === 'Escape') {
+                keyboardEvent.preventDefault();
+                keyboardEvent.stopImmediatePropagation();
+                finish(false);
+            }
+        };
+        useInteractionScope.getState().begin(meshEditScope(nodeId, 'operating', operation));
+        playSfx('operation-start');
+        closeToolbar();
+        setActiveFaceOperation(operation);
+        setFaceOperationAxis('normal');
+        setFaceOperationValue('0');
+        setTransformNumericInput('');
+        setModalFeedbackMode('free');
+        setError(null);
+        beginBlockModalSession({
+            beginInputDrag,
+            cancelRef,
+            cursor: operation === 'extrude' ? 'ns-resize' : 'nwse-resize',
+            onFinish: complete,
+            onKeyDown,
+            onPointerDown,
+            onPointerMove: onMove,
+        });
+        return true;
+    }, [
+        beginInputDrag,
+        camera,
+        cancelRef,
+        canvas,
+        closeToolbar,
+        commit,
+        displayTopology,
+        extent,
+        lastPointerClientRef,
+        mode,
+        nodeId,
+        ownsEditSession,
+        playSfx,
+        sceneApi,
+        selectedIds,
+        selection,
+        setActiveFaceOperation,
+        setError,
+        setFaceOperationAxis,
+        setFaceOperationValue,
+        setModalFeedbackMode,
+        setPreviewTopology,
+        setTransformNumericInput,
+        target,
+    ]);
+}

package/dist/box-vent/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/box-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AA4ItC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAwDhE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/box-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AA4ItC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CA2DhE,CAAA"}

package/dist/box-vent/definition.js

@@ -1,6 +1,6 @@
 import { BoxVentNode as BoxVentNodeSchema, } from '@pascal-app/core';
-import { surfacePaintCapability } from '../shared/surface-paint';
 import { buildBoxVentFloorplan } from './floorplan';
+import { boxVentPaint } from './paint';
 import { boxVentParametrics } from './parametrics';
 import { BoxVentNode } from './schema';
 // Edge-to-arrow-center offset, matching the chimney / dormer cadence.
@@ -161,7 +161,7 @@ const boxVentHandles = [
  */
 export const boxVentDefinition = {
     kind: 'box-vent',
-    schemaVersion: 1,
+    schemaVersion: 3,
     schema: BoxVentNode,
     category: 'structure',
     surfaceRole: 'roof',
@@ -171,11 +171,14 @@ export const boxVentDefinition = {
         return rest;
     },
     capabilities: {
+        slots: () => [
+            { slotId: 'base', label: 'Base', default: 'library:preset-softwhite' },
+            { slotId: 'top', label: 'Top', default: 'library:preset-softwhite' },
+        ],
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
-        // Single painted surface — registry-driven paint dispatch (see chimney).
-        paint: surfacePaintCapability,
+        paint: boxVentPaint,
         // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
         // slope — no `buildCut`, just the dirty cascade so the parent
         // roof's merged shell rebuilds when the vent moves / resizes.
@@ -200,7 +203,7 @@ export const boxVentDefinition = {
     presentation: {
         label: 'Box Vent',
         description: 'Small louvered exhaust vent that sits on a roof slope.',
-        icon: { kind: 'url', src: '/icons/roof.webp' },
+        icon: { kind: 'url', src: '/icons/box-vent.webp' },
         paletteSection: 'structure',
         paletteOrder: 120,
     },

package/dist/box-vent/geometry.d.ts

@@ -1,5 +1,9 @@
 import { type BoxVentNode, type RoofType } from '@pascal-app/core';
 import * as THREE from 'three';
+export declare const BOX_VENT_MATERIAL_INDEX: {
+    readonly base: 0;
+    readonly top: 1;
+};
 /**
  * Pure builder for the box-vent mesh. Models a real attic box vent:
  *

package/dist/box-vent/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/box-vent/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAuB,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACvF,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,KAAK,CAAC,cAAc,CAI5E;AA+kBD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,EACxF,MAAM,EAAE,MAAM,GACb,MAAM,CAKR"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/box-vent/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAuB,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACvF,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,eAAO,MAAM,uBAAuB;;;CAG1B,CAAA;AAEV;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,KAAK,CAAC,cAAc,CAI5E;AAwnBD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,EACxF,MAAM,EAAE,MAAM,GACb,MAAM,CAKR"}