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

package/dist/block/contextual-help.d.ts

@@ -0,0 +1,3 @@
+import type { ContextualHelpNodeExtension } from '@pascal-app/editor';
+export declare const blockContextualHelp: ContextualHelpNodeExtension;
+//# sourceMappingURL=contextual-help.d.ts.map

package/dist/block/contextual-help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextual-help.d.ts","sourceRoot":"","sources":["../../src/block/contextual-help.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAA0B,MAAM,oBAAoB,CAAA;AAwC7F,eAAO,MAAM,mBAAmB,EAAE,2BAMjC,CAAA"}

package/dist/block/contextual-help.js

@@ -0,0 +1,38 @@
+import useBlockEditSession from './edit-session';
+const MODE_LABELS = {
+    vertex: 'Vertex',
+    edge: 'Edge',
+    face: 'Face',
+};
+const MODE_OPERATIONS = {
+    vertex: [{ keys: ['M'], label: 'Merge selected vertices' }],
+    edge: [
+        { keys: ['Cmd/Ctrl', 'B'], label: 'Bevel selected edges' },
+        { keys: ['D'], label: 'Dissolve selected edges' },
+    ],
+    face: [
+        { keys: ['E'], label: 'Extrude selected faces' },
+        { keys: ['I'], label: 'Inset selected faces' },
+    ],
+};
+const HINTS_BY_MODE = Object.fromEntries(Object.keys(MODE_LABELS).map((mode) => [
+    mode,
+    [
+        {
+            keys: [['1', '2', '3']],
+            label: `${MODE_LABELS[mode]} mode`,
+            subtitle: 'Vertex / Edge / Face',
+        },
+        { keys: [['G', 'R', 'S']], label: 'Move / Rotate / Scale selection' },
+        ...MODE_OPERATIONS[mode],
+        { keys: ['Tab'], label: 'Exit mesh editing' },
+    ],
+]));
+const EMPTY_HINTS = [];
+export const blockContextualHelp = {
+    subscribe: useBlockEditSession.subscribe,
+    getHints: (nodeId) => {
+        const session = useBlockEditSession.getState();
+        return session.nodeId === nodeId ? HINTS_BY_MODE[session.selection.mode] : EMPTY_HINTS;
+    },
+};

package/dist/block/definition.d.ts

@@ -0,0 +1,8 @@
+import { type BlockNode as BlockNodeType, type NodeDefinition } from '@pascal-app/core';
+import { BlockNode } from './schema';
+export declare function blockBounds(node: BlockNodeType): {
+    size: [number, number, number];
+    center: [number, number, number];
+};
+export declare const blockDefinition: NodeDefinition<typeof BlockNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/block/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,IAAI,aAAa,EAE/B,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAQzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC,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,CA2F5D,CAAA"}

package/dist/block/definition.js

@@ -0,0 +1,126 @@
+import { createBoxBlockTopology, } from '@pascal-app/core';
+import { blockContextualHelp } from './contextual-help';
+import { blockFaceHost } from './face-host';
+import { buildBlockFloorplan } from './floorplan';
+import { buildBlockGeometry } from './geometry';
+import { blockPaint } from './paint';
+import { blockParametrics } from './parametrics';
+import { BlockNode } from './schema';
+import { blockSlots } from './slots';
+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'),
+            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: {
+        selectable: { hitVolume: 'bbox' },
+        surfaces: {
+            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: 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: true,
+        },
+        paint: blockPaint,
+        slots: (rawNode) => blockSlots(rawNode),
+        faceHost: blockFaceHost,
+    },
+    relations: {
+        hosts: ['item'],
+        cascadeDelete: 'descendants',
+    },
+    geometry: buildBlockGeometry,
+    geometryKey: (node) => JSON.stringify([node.topology, node.slots]),
+    floorplan: buildBlockFloorplan,
+    parametrics: blockParametrics,
+    affordanceTools: {
+        selection: () => import('./selection'),
+    },
+    preview: () => import('./preview'),
+    tool: () => import('./tool'),
+    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.',
+    },
+};

package/dist/block/edit-session.d.ts

@@ -0,0 +1,16 @@
+import type { BlockTopology } from '@pascal-app/core';
+import type { BlockLastOperation } from './last-operation';
+import { type BlockSelectionState } from './selection-model';
+type BlockEditSessionState = {
+    nodeId: string | null;
+    selection: BlockSelectionState;
+    lastOperation: BlockLastOperation | null;
+    begin: (nodeId: string, selection: BlockSelectionState) => void;
+    end: (nodeId: string) => void;
+    setSelection: (nodeId: string, selection: BlockSelectionState) => void;
+    reconcileSelection: (nodeId: string, topology: BlockTopology) => void;
+    setLastOperation: (nodeId: string, operation: BlockLastOperation | null) => void;
+};
+declare const useBlockEditSession: import("zustand").UseBoundStore<import("zustand").StoreApi<BlockEditSessionState>>;
+export default useBlockEditSession;
+//# sourceMappingURL=edit-session.d.ts.map

package/dist/block/edit-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-session.d.ts","sourceRoot":"","sources":["../../src/block/edit-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,KAAK,mBAAmB,EAAwB,MAAM,mBAAmB,CAAA;AAElF,KAAK,qBAAqB,GAAG;IAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,SAAS,EAAE,mBAAmB,CAAA;IAC9B,aAAa,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,KAAK,IAAI,CAAA;IAC/D,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,KAAK,IAAI,CAAA;IACtE,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAA;IACrE,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,GAAG,IAAI,KAAK,IAAI,CAAA;CACjF,CAAA;AAID,QAAA,MAAM,mBAAmB,oFAmCtB,CAAA;AAEH,eAAe,mBAAmB,CAAA"}

package/dist/block/edit-session.js

@@ -0,0 +1,32 @@
+import { create } from 'zustand';
+import { createBlockSelection } from './selection-model';
+const emptySelection = () => createBlockSelection('face');
+const useBlockEditSession = create((set) => ({
+    nodeId: null,
+    selection: emptySelection(),
+    lastOperation: null,
+    begin: (nodeId, selection) => set({ nodeId, selection, lastOperation: null }),
+    end: (nodeId) => set((state) => state.nodeId === nodeId
+        ? { nodeId: null, selection: emptySelection(), lastOperation: null }
+        : state),
+    setSelection: (nodeId, selection) => set((state) => (state.nodeId === nodeId ? { selection } : state)),
+    setLastOperation: (nodeId, lastOperation) => set((state) => (state.nodeId === nodeId ? { lastOperation } : state)),
+    reconcileSelection: (nodeId, topology) => set((state) => {
+        if (state.nodeId !== nodeId)
+            return state;
+        const validIds = new Set(state.selection.mode === 'vertex'
+            ? topology.vertices.map((vertex) => vertex.id)
+            : state.selection.mode === 'edge'
+                ? topology.edges.map((edge) => edge.id)
+                : topology.faces.map((face) => face.id));
+        const ids = state.selection.ids.filter((id) => validIds.has(id));
+        const activeId = state.selection.activeId && ids.includes(state.selection.activeId)
+            ? state.selection.activeId
+            : (ids.at(-1) ?? null);
+        if (ids.length === state.selection.ids.length && activeId === state.selection.activeId) {
+            return state;
+        }
+        return { selection: { ...state.selection, ids, activeId } };
+    }),
+}));
+export default useBlockEditSession;

package/dist/block/face-host.d.ts

@@ -0,0 +1,3 @@
+import { type BlockNode, type FaceHostCapability } from '@pascal-app/core';
+export declare const blockFaceHost: FaceHostCapability<BlockNode>;
+//# sourceMappingURL=face-host.d.ts.map

package/dist/block/face-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"face-host.d.ts","sourceRoot":"","sources":["../../src/block/face-host.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,kBAAkB,EAGxB,MAAM,kBAAkB,CAAA;AAqLzB,eAAO,MAAM,aAAa,EAAE,kBAAkB,CAAC,SAAS,CA+BvD,CAAA"}

package/dist/block/face-host.js

@@ -0,0 +1,178 @@
+import { getBlockFaceFrame, } from '@pascal-app/core';
+import { Euler, Matrix4, Quaternion, Vector3 } from 'three';
+const BLOCK_HORIZONTAL_NORMAL_MIN_Y = 0.95;
+const BLOCK_VERTICAL_NORMAL_MAX_Y = 0.05;
+const BLOCK_FLOOR_ROTATION_X = Math.PI / 2;
+const BLOCK_CEILING_ROTATION_X = -Math.PI / 2;
+const BLOCK_FACE_STICKY_PLANE_EPSILON = 0.08;
+function blockFaceAcceptsAttachment(normalY, attachTo) {
+    if (!attachTo)
+        return normalY >= BLOCK_HORIZONTAL_NORMAL_MIN_Y;
+    if (attachTo === 'ceiling')
+        return normalY <= -BLOCK_HORIZONTAL_NORMAL_MIN_Y;
+    if (attachTo === 'wall' || attachTo === 'wall-side') {
+        return Math.abs(normalY) <= BLOCK_VERTICAL_NORMAL_MAX_Y;
+    }
+    return false;
+}
+function blockHitFaceId(args) {
+    if (args.faceIndex == null)
+        return null;
+    const geometry = args.object.geometry;
+    const ranges = geometry?.userData?.blockFaces;
+    if (!Array.isArray(ranges))
+        return null;
+    const triangleStart = args.faceIndex * 3;
+    const range = ranges.find((candidate) => triangleStart >= candidate.start && triangleStart < candidate.start + candidate.count);
+    return range?.faceId ?? null;
+}
+function clampBlockFacePosition(position, bounds, dimensions) {
+    const [width, height] = dimensions;
+    const minU = bounds.minU + width / 2;
+    const maxU = bounds.maxU - width / 2;
+    const minV = bounds.minV;
+    const maxV = bounds.maxV - height;
+    if (minU > maxU || minV > maxV)
+        return null;
+    return [
+        Math.min(maxU, Math.max(minU, position[0])),
+        Math.min(maxV, Math.max(minV, position[1])),
+        position[2],
+    ];
+}
+function clampBlockFaceCenterPosition(position, bounds, dimensions) {
+    const [width, depth] = dimensions;
+    const minU = bounds.minU + width / 2;
+    const maxU = bounds.maxU - width / 2;
+    const minV = bounds.minV + depth / 2;
+    const maxV = bounds.maxV - depth / 2;
+    if (minU > maxU || minV > maxV)
+        return null;
+    return [
+        Math.min(maxU, Math.max(minU, position[0])),
+        Math.min(maxV, Math.max(minV, position[1])),
+        position[2],
+    ];
+}
+function resolveBlockFaceTargetForFace(args, faceId, options = {}) {
+    const attachTo = args.asset.attachTo;
+    const frame = getBlockFaceFrame(args.host.topology, faceId);
+    if (!frame)
+        return null;
+    if (!blockFaceAcceptsAttachment(frame.normal[1], attachTo))
+        return null;
+    const hit = new Vector3(...args.localPosition).sub(new Vector3(...frame.origin));
+    const xAxis = new Vector3(...frame.xAxis);
+    const yAxis = new Vector3(...frame.yAxis);
+    const normal = new Vector3(...frame.normal);
+    if (options.requirePointerOnPlane &&
+        Math.abs(hit.dot(normal)) > BLOCK_FACE_STICKY_PLANE_EPSILON) {
+        return null;
+    }
+    const face = args.host.topology.faces.find((candidate) => candidate.id === faceId);
+    if (!face)
+        return null;
+    const vertices = new Map(args.host.topology.vertices.map((vertex) => [vertex.id, vertex.position]));
+    let minU = Number.POSITIVE_INFINITY;
+    let maxU = Number.NEGATIVE_INFINITY;
+    let minV = Number.POSITIVE_INFINITY;
+    let maxV = Number.NEGATIVE_INFINITY;
+    for (const vertexId of face.vertexIds) {
+        const point = vertices.get(vertexId);
+        if (!point)
+            return null;
+        const dx = point[0] - frame.origin[0];
+        const dy = point[1] - frame.origin[1];
+        const dz = point[2] - frame.origin[2];
+        const pointU = dx * xAxis.x + dy * xAxis.y + dz * xAxis.z;
+        const pointV = dx * yAxis.x + dy * yAxis.y + dz * yAxis.z;
+        minU = Math.min(minU, pointU);
+        maxU = Math.max(maxU, pointU);
+        minV = Math.min(minV, pointV);
+        maxV = Math.max(maxV, pointV);
+    }
+    const [width, height, depth] = args.dimensions;
+    const snappedPosition = [
+        args.snapScalar(hit.dot(xAxis)),
+        args.snapScalar(hit.dot(yAxis)),
+        0,
+    ];
+    const faceBounds = { minU, maxU, minV, maxV };
+    const facePosition = !attachTo || attachTo === 'ceiling'
+        ? clampBlockFaceCenterPosition(snappedPosition, faceBounds, [width, depth])
+        : clampBlockFacePosition(snappedPosition, faceBounds, [width, height]);
+    if (!facePosition)
+        return null;
+    const [u, v] = facePosition;
+    const normalOffset = attachTo === 'ceiling' && !args.asset.recessed ? args.rawDimensions[1] : 0;
+    const position = [u, v, normalOffset];
+    const localPoint = new Vector3(...frame.origin)
+        .addScaledVector(xAxis, u)
+        .addScaledVector(yAxis, v)
+        .addScaledVector(normal, normalOffset);
+    args.object.updateWorldMatrix(true, false);
+    const worldPoint = args.object.localToWorld(localPoint);
+    const localFrame = new Matrix4().makeBasis(xAxis, yAxis, normal);
+    const worldFrame = new Matrix4().copy(args.object.matrixWorld).multiply(localFrame);
+    const worldQuaternion = new Quaternion();
+    worldFrame.decompose(new Vector3(), worldQuaternion, new Vector3());
+    const rotation = !attachTo
+        ? [BLOCK_FLOOR_ROTATION_X, 0, 0]
+        : attachTo === 'ceiling'
+            ? [BLOCK_CEILING_ROTATION_X, 0, 0]
+            : [0, 0, 0];
+    worldQuaternion.multiply(new Quaternion().setFromEuler(new Euler(...rotation)));
+    const cursorRotation = new Euler().setFromQuaternion(worldQuaternion, 'XYZ');
+    return {
+        faceId,
+        nodeUpdate: {
+            position,
+            parentId: args.host.id,
+            blockFaceId: faceId,
+            roofSegmentId: undefined,
+            roofFace: undefined,
+            wallId: undefined,
+            side: 'front',
+            rotation,
+        },
+        position,
+        rotation,
+        cursorPosition: worldPoint.toArray(),
+        cursorRotation: [cursorRotation.x, cursorRotation.y, cursorRotation.z],
+    };
+}
+export const blockFaceHost = {
+    currentFaceId: (item) => item?.blockFaceId ?? null,
+    clearItemFields: ['position', 'rotation', 'blockFaceId'],
+    resolvePlacement: (args) => {
+        if (args.currentFaceId) {
+            const currentTarget = resolveBlockFaceTargetForFace(args, args.currentFaceId, {
+                requirePointerOnPlane: true,
+            });
+            if (currentTarget)
+                return currentTarget;
+        }
+        const faceId = blockHitFaceId(args);
+        return faceId ? resolveBlockFaceTargetForFace(args, faceId) : null;
+    },
+    storedPlacementPatch: ({ host, item, position }) => {
+        if (!item.blockFaceId)
+            return null;
+        return {
+            position: [position[0], position[1], position[2]],
+            parentId: host.id,
+            blockFaceId: item.blockFaceId,
+            roofSegmentId: undefined,
+            roofFace: undefined,
+            wallId: undefined,
+            side: 'front',
+            rotation: item.rotation,
+        };
+    },
+    isStoredPlacementValid: ({ host, item, asset }) => {
+        if (!item.blockFaceId)
+            return false;
+        const frame = getBlockFaceFrame(host.topology, item.blockFaceId);
+        return !!(frame && blockFaceAcceptsAttachment(frame.normal[1], asset.attachTo));
+    },
+};

package/dist/block/floorplan.d.ts

@@ -0,0 +1,3 @@
+import type { BlockNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+export declare function buildBlockFloorplan(node: BlockNode, ctx?: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/block/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAuBzB,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,GAAG,CAAC,EAAE,eAAe,GACpB,iBAAiB,GAAG,IAAI,CAqB1B"}

package/dist/block/floorplan.js

@@ -0,0 +1,43 @@
+function cross(origin, a, b) {
+    return (a[0] - origin[0]) * (b[1] - origin[1]) - (a[1] - origin[1]) * (b[0] - origin[0]);
+}
+function convexHull(points) {
+    const unique = [...new Map(points.map((point) => [`${point[0]}:${point[1]}`, point])).values()];
+    if (unique.length <= 3)
+        return unique;
+    unique.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    const lower = [];
+    for (const point of unique) {
+        while (lower.length >= 2 && cross(lower.at(-2), lower.at(-1), point) <= 0)
+            lower.pop();
+        lower.push(point);
+    }
+    const upper = [];
+    for (const point of [...unique].reverse()) {
+        while (upper.length >= 2 && cross(upper.at(-2), upper.at(-1), point) <= 0)
+            upper.pop();
+        upper.push(point);
+    }
+    return [...lower.slice(0, -1), ...upper.slice(0, -1)];
+}
+export function buildBlockFloorplan(node, ctx) {
+    const points = convexHull(node.topology.vertices.map((vertex) => [vertex.position[0], vertex.position[2]]));
+    if (points.length < 3)
+        return null;
+    const selected = ctx?.viewState?.selected ?? false;
+    return {
+        kind: 'group',
+        transform: { translate: [node.position[0], node.position[2]], rotate: -node.rotation },
+        children: [
+            {
+                kind: 'polygon',
+                points,
+                fill: selected ? '#fed7aa' : '#cbd5e1',
+                fillOpacity: selected ? 0.55 : 0.72,
+                stroke: selected ? (ctx?.viewState?.palette?.selectedStroke ?? '#f97316') : '#475569',
+                strokeWidth: selected ? 0.03 : 0.018,
+                pointerEvents: 'all',
+            },
+        ],
+    };
+}

package/dist/block/geometry-snap.d.ts

@@ -0,0 +1,18 @@
+import type { BlockTopology } from '@pascal-app/core';
+import { type Camera, Vector3 } from 'three';
+import { type BlockSelection } from './commands';
+import type { BlockTransformConstraint } from './modal-transform';
+type Point = [number, number, number];
+export type BlockGeometrySnap = {
+    delta: Point;
+    kind: 'vertex' | 'edge' | 'face';
+    source: Point;
+    target: Point;
+    targetId: string;
+};
+export declare function blockGeometrySnapThreshold(camera: Camera, worldPoint: Vector3, viewportHeight: number, worldScale: Vector3, radiusPixels?: number): number;
+export declare function resolveBlockGeometrySnap(topology: BlockTopology, selection: BlockSelection & {
+    activeId?: string | null;
+}, proposedDelta: Point, constraint: BlockTransformConstraint, threshold: number): BlockGeometrySnap | null;
+export {};
+//# sourceMappingURL=geometry-snap.d.ts.map

package/dist/block/geometry-snap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-snap.d.ts","sourceRoot":"","sources":["../../src/block/geometry-snap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,EACL,KAAK,MAAM,EAKX,OAAO,EACR,MAAM,OAAO,CAAA;AACd,OAAO,EAAE,KAAK,cAAc,EAA2B,MAAM,YAAY,CAAA;AAEzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AAEjE,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAErC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAA;IAChC,MAAM,EAAE,KAAK,CAAA;IACb,MAAM,EAAE,KAAK,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,OAAO,EACnB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,OAAO,EACnB,YAAY,SAAK,GAChB,MAAM,CAiBR;AA8BD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,cAAc,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACxD,aAAa,EAAE,KAAK,EACpB,UAAU,EAAE,wBAAwB,EACpC,SAAS,EAAE,MAAM,GAChB,iBAAiB,GAAG,IAAI,CA+F1B"}

package/dist/block/geometry-snap.js

@@ -0,0 +1,137 @@
+import { MathUtils, OrthographicCamera, PerspectiveCamera, Triangle, Vector3, } from 'three';
+import { blockSelectionVertexIds } from './commands';
+import { triangulateBlockFace } from './geometry';
+export function blockGeometrySnapThreshold(camera, worldPoint, viewportHeight, worldScale, radiusPixels = 18) {
+    let worldUnitsPerPixel = 0;
+    if (camera instanceof PerspectiveCamera) {
+        const cameraDepth = Math.abs(worldPoint.clone().applyMatrix4(camera.matrixWorldInverse).z);
+        worldUnitsPerPixel =
+            (2 * cameraDepth * Math.tan(MathUtils.degToRad(camera.getEffectiveFOV() * 0.5))) /
+                Math.max(viewportHeight, 1);
+    }
+    else if (camera instanceof OrthographicCamera) {
+        worldUnitsPerPixel = (camera.top - camera.bottom) / Math.max(camera.zoom * viewportHeight, 1);
+    }
+    const largestWorldScale = Math.max(Math.abs(worldScale.x), Math.abs(worldScale.y), Math.abs(worldScale.z), 1e-6);
+    return (worldUnitsPerPixel * radiusPixels) / largestWorldScale;
+}
+function centroid(points) {
+    if (points.length === 0)
+        return null;
+    const total = points.reduce((sum, point) => [sum[0] + point[0], sum[1] + point[1], sum[2] + point[2]], [0, 0, 0]);
+    return total.map((value) => value / points.length);
+}
+function closestPointOnSegment(point, start, end) {
+    const segment = new Vector3(...end).sub(new Vector3(...start));
+    const lengthSquared = segment.lengthSq();
+    if (lengthSquared < 1e-12)
+        return [...start];
+    const factor = Math.min(1, Math.max(0, new Vector3(...point).sub(new Vector3(...start)).dot(segment) / lengthSquared));
+    return new Vector3(...start).addScaledVector(segment, factor).toArray();
+}
+function constrainedCorrection(correction, constraint) {
+    if (constraint === 'free' || constraint === 'uniform')
+        return correction;
+    return correction.map((value, index) => {
+        const axis = index === 0 ? 'x' : index === 1 ? 'y' : 'z';
+        return constraint.includes(axis) ? value : 0;
+    });
+}
+export function resolveBlockGeometrySnap(topology, selection, proposedDelta, constraint, threshold) {
+    if (!(threshold > 0))
+        return null;
+    const vertexById = new Map(topology.vertices.map((vertex) => [vertex.id, vertex.position]));
+    const selectedVertexIds = blockSelectionVertexIds(topology, selection);
+    const selectedPoints = [...selectedVertexIds]
+        .map((id) => vertexById.get(id))
+        .filter((point) => Boolean(point));
+    if (selectedPoints.length === 0)
+        return null;
+    const sources = [];
+    if (selection.activeId) {
+        if (selection.mode === 'vertex') {
+            const point = vertexById.get(selection.activeId);
+            if (point)
+                sources.push(point);
+        }
+        else if (selection.mode === 'edge') {
+            const edge = topology.edges.find((entry) => entry.id === selection.activeId);
+            const points = edge?.vertexIds
+                .map((id) => vertexById.get(id))
+                .filter((point) => Boolean(point));
+            const point = points ? centroid(points) : null;
+            if (point)
+                sources.push(point);
+        }
+        else {
+            const face = topology.faces.find((entry) => entry.id === selection.activeId);
+            const points = face?.vertexIds
+                .map((id) => vertexById.get(id))
+                .filter((point) => Boolean(point));
+            const point = points ? centroid(points) : null;
+            if (point)
+                sources.push(point);
+        }
+    }
+    sources.push(...selectedPoints);
+    const selectionCenter = centroid(selectedPoints);
+    if (selectionCenter)
+        sources.push(selectionCenter);
+    let best = null;
+    const consider = (source, target, kind, targetId) => {
+        const movedSource = source.map((value, index) => value + proposedDelta[index]);
+        const correction = target.map((value, index) => value - movedSource[index]);
+        if (Math.hypot(...correction) > threshold)
+            return;
+        const allowedCorrection = constrainedCorrection(correction, constraint);
+        const distance = Math.hypot(...allowedCorrection);
+        if (distance <= 1e-8 || (best && distance >= best.distance))
+            return;
+        best = {
+            delta: proposedDelta.map((value, index) => value + allowedCorrection[index]),
+            distance,
+            kind,
+            source,
+            target,
+            targetId,
+        };
+    };
+    for (const source of sources) {
+        const movedSource = source.map((value, index) => value + proposedDelta[index]);
+        for (const vertex of topology.vertices) {
+            if (!selectedVertexIds.has(vertex.id))
+                consider(source, vertex.position, 'vertex', vertex.id);
+        }
+        for (const edge of topology.edges) {
+            if (edge.vertexIds.some((id) => selectedVertexIds.has(id)))
+                continue;
+            const start = vertexById.get(edge.vertexIds[0]);
+            const end = vertexById.get(edge.vertexIds[1]);
+            if (start && end) {
+                consider(source, closestPointOnSegment(movedSource, start, end), 'edge', edge.id);
+            }
+        }
+        for (const face of topology.faces) {
+            if (face.vertexIds.some((id) => selectedVertexIds.has(id)))
+                continue;
+            const triangulated = triangulateBlockFace(topology, face);
+            if (!triangulated)
+                continue;
+            for (const points of triangulated.triangles) {
+                const triangle = new Triangle(new Vector3(...points[0]), new Vector3(...points[1]), new Vector3(...points[2]));
+                const target = triangle.closestPointToPoint(new Vector3(...movedSource), new Vector3());
+                consider(source, target.toArray(), 'face', face.id);
+            }
+        }
+    }
+    if (!best)
+        return null;
+    const resolved = best;
+    return {
+        delta: resolved.delta,
+        kind: resolved.kind,
+        source: resolved.source,
+        target: resolved.target,
+        targetId: resolved.targetId,
+    };
+}

package/dist/block/geometry.d.ts

@@ -0,0 +1,11 @@
+import type { BlockFace, BlockNode, BlockTopology, GeometryContext } from '@pascal-app/core';
+import { type ColorPreset, type RenderShading } from '@pascal-app/viewer';
+import { Group } from 'three';
+type Point = [number, number, number];
+export declare function triangulateBlockFace(topology: BlockTopology, face: BlockFace): {
+    triangles: [Point, Point, Point][];
+    normal: Point;
+} | null;
+export declare function buildBlockGeometry(node: BlockNode, ctx?: Pick<GeometryContext, 'materials'>, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): Group;
+export {};
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/block/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAC5F,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAIL,KAAK,EAKN,MAAM,OAAO,CAAA;AAId,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAYrC,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,SAAS,GACd;IAAE,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;IAAC,MAAM,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CA8B9D;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,EACf,GAAG,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,EACxC,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CAwGP"}