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

package/dist/shared/fitting-deletion-cleanup.js

@@ -0,0 +1,297 @@
+import { Euler, Matrix4, Quaternion, Vector3 } from 'three';
+import { getDuctFittingPorts } from '../duct-fitting/ports';
+import { getPipeFittingPorts } from '../pipe-fitting/ports';
+const MATE_TOLERANCE_SQ = 0.05 ** 2;
+const DIRECTION_TOLERANCE = 1e-4;
+function distanceSquared(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return dx * dx + dy * dy + dz * dz;
+}
+function fittingPorts(fitting) {
+    return fitting.type === 'duct-fitting'
+        ? getDuctFittingPorts(fitting)
+        : getPipeFittingPorts(fitting);
+}
+function fittingConnections(fitting, nodes) {
+    const runType = fitting.type === 'duct-fitting' ? 'duct-segment' : 'pipe-segment';
+    const connections = [];
+    for (const port of fittingPorts(fitting)) {
+        let match;
+        for (const node of Object.values(nodes)) {
+            if (node.type !== runType || node.system !== fitting.system)
+                continue;
+            const run = node;
+            const endIndices = [0, run.path.length - 1];
+            for (const endIndex of endIndices) {
+                const endpoint = run.path[endIndex];
+                if (endpoint && distanceSquared(endpoint, port.position) <= MATE_TOLERANCE_SQ) {
+                    match = { portId: port.id, port, run, endIndex };
+                    break;
+                }
+            }
+            if (match)
+                break;
+        }
+        if (match)
+            connections.push(match);
+    }
+    return connections;
+}
+function frame(primary, reference) {
+    const x = primary.clone().normalize();
+    const z = new Vector3().crossVectors(x, reference);
+    if (z.lengthSq() < 1e-10)
+        return null;
+    z.normalize();
+    const y = new Vector3().crossVectors(z, x);
+    return new Matrix4().makeBasis(x, y, z);
+}
+function rotationMapping(localPrimary, localReference, worldPrimary, worldReference) {
+    const localFrame = frame(localPrimary, localReference);
+    const worldFrame = frame(worldPrimary, worldReference);
+    if (!localFrame || !worldFrame)
+        return null;
+    const rotation = new Quaternion().setFromRotationMatrix(worldFrame.multiply(localFrame.transpose()));
+    const euler = new Euler().setFromQuaternion(rotation);
+    return [euler.x, euler.y, euler.z];
+}
+function direction(connection) {
+    return new Vector3(...connection.port.direction).normalize();
+}
+function ductProfile(fitting, portId) {
+    const secondary = portId === 'branch' || portId === 'branch2';
+    return secondary
+        ? {
+            shape: fitting.shape2,
+            width: fitting.width2,
+            height: fitting.height2,
+            diameter: fitting.diameter2,
+        }
+        : {
+            shape: fitting.shape,
+            width: fitting.width,
+            height: fitting.height,
+            diameter: fitting.diameter,
+        };
+}
+function fittingPatchForTee(fitting, runConnection, branchConnection, rotation) {
+    if (fitting.type === 'duct-fitting') {
+        const run = ductProfile(fitting, runConnection.portId);
+        const branch = ductProfile(fitting, branchConnection.portId);
+        return {
+            name: 'Tee',
+            fittingType: 'tee',
+            rotation,
+            branchAngle: 90,
+            shape: run.shape,
+            width: run.width,
+            height: run.height,
+            diameter: run.diameter,
+            shape2: branch.shape,
+            width2: branch.width,
+            height2: branch.height,
+            diameter2: branch.diameter,
+        };
+    }
+    const runDiameter = runConnection.portId === 'branch' || runConnection.portId === 'branch2'
+        ? fitting.diameter2
+        : fitting.diameter;
+    const branchDiameter = branchConnection.portId === 'branch' || branchConnection.portId === 'branch2'
+        ? fitting.diameter2
+        : fitting.diameter;
+    return {
+        name: 'Sanitary tee',
+        fittingType: 'sanitary-tee',
+        rotation,
+        diameter: runDiameter,
+        diameter2: branchDiameter,
+    };
+}
+function fittingPatchForElbow(fitting, connection, angle, rotation) {
+    if (fitting.type === 'duct-fitting') {
+        const profile = ductProfile(fitting, connection.portId);
+        return {
+            name: 'Elbow',
+            fittingType: 'elbow',
+            rotation,
+            angle,
+            shape: profile.shape,
+            width: profile.width,
+            height: profile.height,
+            diameter: profile.diameter,
+            diameter2: profile.diameter,
+        };
+    }
+    const diameter = connection.portId === 'branch' || connection.portId === 'branch2'
+        ? fitting.diameter2
+        : fitting.diameter;
+    return {
+        name: 'Elbow',
+        fittingType: 'elbow',
+        rotation,
+        angle,
+        diameter,
+        diameter2: diameter,
+    };
+}
+function endpointUpdates(connections, targets) {
+    return connections.flatMap((connection) => {
+        const target = targets.get(connection);
+        if (!target)
+            return [];
+        const path = connection.run.path.map((point) => [...point]);
+        path[connection.endIndex] = [...target];
+        return [{ id: connection.run.id, data: { path } }];
+    });
+}
+function removalPlan(fitting, remaining) {
+    const target = fitting.position;
+    const targets = new Map(remaining.map((connection) => [connection, target]));
+    return {
+        fittingId: fitting.id,
+        deleteFitting: true,
+        cascadeDeleteIds: [],
+        updates: endpointUpdates(remaining, targets),
+    };
+}
+function pathFromOuterEnd(connection) {
+    const path = connection.run.path.map((point) => [...point]);
+    return connection.endIndex === 0 ? path.reverse() : path;
+}
+function pathTowardOuterEnd(connection) {
+    const path = connection.run.path.map((point) => [...point]);
+    return connection.endIndex === 0 ? path : path.reverse();
+}
+function straightMergePlan(fitting, remaining) {
+    const [primary, secondary] = remaining;
+    const primarySide = pathFromOuterEnd(primary);
+    const secondarySide = pathTowardOuterEnd(secondary);
+    const path = [...primarySide.slice(0, -1), ...secondarySide.slice(1)];
+    return {
+        fittingId: fitting.id,
+        deleteFitting: true,
+        cascadeDeleteIds: [secondary.run.id],
+        updates: [{ id: primary.run.id, data: { path } }],
+    };
+}
+function teePlan(fitting, remaining) {
+    let pair = null;
+    for (let i = 0; i < remaining.length; i += 1) {
+        for (let j = i + 1; j < remaining.length; j += 1) {
+            if (direction(remaining[i]).dot(direction(remaining[j])) < -1 + DIRECTION_TOLERANCE) {
+                pair = [remaining[i], remaining[j]];
+                break;
+            }
+        }
+        if (pair)
+            break;
+    }
+    if (!pair)
+        return null;
+    const branch = remaining.find((connection) => !pair?.includes(connection));
+    if (!branch)
+        return null;
+    const rotation = rotationMapping(new Vector3(1, 0, 0), new Vector3(0, 0, 1), direction(pair[1]), direction(branch));
+    if (!rotation)
+        return null;
+    const patch = fittingPatchForTee(fitting, pair[0], branch, rotation);
+    const nextFitting = { ...fitting, ...patch };
+    const nextPorts = new Map(fittingPorts(nextFitting).map((port) => [port.id, port]));
+    const portAssignments = new Map([
+        [pair[0], 'inlet'],
+        [pair[1], 'outlet'],
+        [branch, 'branch'],
+    ]);
+    const targets = new Map();
+    for (const connection of remaining) {
+        const port = nextPorts.get(portAssignments.get(connection) ?? '');
+        if (port)
+            targets.set(connection, port.position);
+    }
+    return {
+        fittingId: fitting.id,
+        deleteFitting: false,
+        cascadeDeleteIds: [],
+        updates: [
+            { id: fitting.id, data: patch },
+            ...endpointUpdates(remaining, targets),
+        ],
+    };
+}
+function elbowPlan(fitting, remaining) {
+    const first = remaining[0];
+    const second = remaining[1];
+    if (!first || !second)
+        return null;
+    const separation = direction(first).angleTo(direction(second));
+    const angle = 180 - (separation * 180) / Math.PI;
+    if (angle < -DIRECTION_TOLERANCE || angle > 90 + DIRECTION_TOLERANCE)
+        return null;
+    if (angle <= DIRECTION_TOLERANCE)
+        return null;
+    const localOutlet = new Vector3(Math.cos((angle * Math.PI) / 180), 0, Math.sin((angle * Math.PI) / 180));
+    const rotation = rotationMapping(new Vector3(-1, 0, 0), localOutlet, direction(first), direction(second));
+    if (!rotation)
+        return null;
+    const patch = fittingPatchForElbow(fitting, first, Math.min(90, Math.max(0, angle)), rotation);
+    const nextFitting = { ...fitting, ...patch };
+    const nextPorts = new Map(fittingPorts(nextFitting).map((port) => [port.id, port]));
+    const inlet = nextPorts.get('inlet');
+    const outlet = nextPorts.get('outlet');
+    if (!inlet || !outlet)
+        return null;
+    const targets = new Map([
+        [first, inlet.position],
+        [second, outlet.position],
+    ]);
+    return {
+        fittingId: fitting.id,
+        deleteFitting: false,
+        cascadeDeleteIds: [],
+        updates: [
+            { id: fitting.id, data: patch },
+            ...endpointUpdates(remaining, targets),
+        ],
+    };
+}
+function planFittingAfterDeletion(fitting, nodes, topologyDeleteIds) {
+    const remaining = fittingConnections(fitting, nodes).filter((connection) => !topologyDeleteIds.has(connection.run.id));
+    if (remaining.length === 3)
+        return teePlan(fitting, remaining) ?? removalPlan(fitting, remaining);
+    if (remaining.length === 2) {
+        const dot = direction(remaining[0]).dot(direction(remaining[1]));
+        if (dot < -1 + DIRECTION_TOLERANCE) {
+            return straightMergePlan(fitting, [remaining[0], remaining[1]]);
+        }
+        return elbowPlan(fitting, remaining) ?? removalPlan(fitting, remaining);
+    }
+    return removalPlan(fitting, remaining);
+}
+export function fittingDeletionPlansForRun(run, nodes, topologyDeleteIds, ownerOnly) {
+    const fittingType = run.type === 'duct-segment' ? 'duct-fitting' : 'pipe-fitting';
+    const plans = [];
+    for (const node of Object.values(nodes)) {
+        if (node.type !== fittingType)
+            continue;
+        const fitting = node;
+        if (['end-cap', 'damper', 'access-panel', 'cleanout', 'coupling'].includes(fitting.fittingType))
+            continue;
+        const connections = fittingConnections(fitting, nodes);
+        if (!connections.some((connection) => connection.run.id === run.id))
+            continue;
+        if (ownerOnly) {
+            const deletedRunIds = connections
+                .map((connection) => connection.run.id)
+                .filter((id) => topologyDeleteIds.has(id))
+                .sort();
+            if (deletedRunIds[0] !== run.id)
+                continue;
+        }
+        const plan = planFittingAfterDeletion(fitting, nodes, topologyDeleteIds);
+        if (plan)
+            plans.push(plan);
+    }
+    return plans;
+}

package/dist/shared/fitting-surface-support.d.ts

@@ -0,0 +1,5 @@
+import type { DuctFittingNode, PipeFittingNode } from '@pascal-app/core';
+type Point = [number, number, number];
+export declare function createFittingSurfaceSupport(): (node: DuctFittingNode | PipeFittingNode, rotation: Point, position: Point, surfacePoint: Point, surfaceNormal?: Point) => Point;
+export {};
+//# sourceMappingURL=fitting-surface-support.d.ts.map

package/dist/shared/fitting-surface-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitting-surface-support.d.ts","sourceRoot":"","sources":["../../src/shared/fitting-surface-support.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAKxE,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAErC,wBAAgB,2BAA2B,KAIvC,MAAM,eAAe,GAAG,eAAe,EACvC,UAAU,KAAK,EACf,UAAU,KAAK,EACf,cAAc,KAAK,EACnB,gBAAe,KAAiB,KAC/B,KAAK,CAkCT"}

package/dist/shared/fitting-surface-support.js

@@ -0,0 +1,42 @@
+import { Mesh, Vector3 } from 'three';
+import { buildDuctFittingGeometry } from '../duct-fitting/geometry';
+import { buildPipeFittingGeometry } from '../pipe-fitting/geometry';
+export function createFittingSurfaceSupport() {
+    let key = '';
+    let vertices = [];
+    return (node, rotation, position, surfacePoint, surfaceNormal = [0, 1, 0]) => {
+        const nextKey = JSON.stringify([node, rotation]);
+        if (key !== nextKey) {
+            const group = node.type === 'duct-fitting'
+                ? buildDuctFittingGeometry({ ...node, rotation })
+                : buildPipeFittingGeometry({ ...node, rotation });
+            group.rotation.set(...rotation);
+            group.updateMatrixWorld(true);
+            vertices = [];
+            group.traverse((object) => {
+                if (!(object instanceof Mesh))
+                    return;
+                const points = object.geometry.getAttribute('position');
+                for (let i = 0; i < points.count; i++) {
+                    vertices.push(new Vector3().fromBufferAttribute(points, i).applyMatrix4(object.matrixWorld));
+                }
+                object.geometry.dispose();
+            });
+            key = nextKey;
+        }
+        const normal = new Vector3(...surfaceNormal).normalize();
+        if (normal.lengthSq() === 0)
+            normal.set(0, 1, 0);
+        let minimum = Infinity;
+        for (const vertex of vertices)
+            minimum = Math.min(minimum, vertex.dot(normal));
+        if (!Number.isFinite(minimum))
+            return position;
+        const result = new Vector3(...position);
+        const distance = result
+            .clone()
+            .sub(new Vector3(...surfacePoint))
+            .dot(normal);
+        return result.addScaledVector(normal, -distance - minimum + 0.001).toArray();
+    };
+}

package/dist/shared/fitting-tool-options.d.ts

@@ -0,0 +1,4 @@
+import type { ToolOption } from '@pascal-app/core';
+export declare const ductFittingToolOptions: ToolOption[];
+export declare const pipeFittingToolOptions: ToolOption[];
+//# sourceMappingURL=fitting-tool-options.d.ts.map

package/dist/shared/fitting-tool-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitting-tool-options.d.ts","sourceRoot":"","sources":["../../src/shared/fitting-tool-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAmFlD,eAAO,MAAM,sBAAsB,EAAE,UAAU,EA6G9C,CAAA;AACD,eAAO,MAAM,sBAAsB,EAAE,UAAU,EAyC9C,CAAA"}

package/dist/shared/fitting-tool-options.js

@@ -0,0 +1,175 @@
+import { useEditor } from '@pascal-app/editor';
+import { reducerOutletDiameter } from './reducer-size';
+const label = (value) => ({
+    rect: 'Rectangular',
+    pvc: 'PVC',
+    abs: 'ABS',
+    'access-panel': 'Access panel',
+    damper: 'Balancing damper',
+})[value] ?? value.replaceAll('-', ' ').replace(/^./, (c) => c.toUpperCase());
+function option(kind, key, title, choices, fallback, numeric = false, types) {
+    return {
+        id: key,
+        label: title,
+        choices: choices.map((value) => ({
+            value,
+            label: label(value),
+            ...(key === 'fittingType' && value === 'reducer'
+                ? { description: 'Connects matching profiles with different sizes.' }
+                : key === 'fittingType' && value === 'transition'
+                    ? {
+                        description: 'Connects round, rectangular, or oval profiles. Choose the shape and size of each end.',
+                    }
+                    : {}),
+        })),
+        value: () => String(useEditor.getState().toolDefaults[kind]?.[key] ?? fallback),
+        subscribe: (callback) => useEditor.subscribe(callback),
+        set: (value) => {
+            const defaults = {
+                ...useEditor.getState().toolDefaults[kind],
+                [key]: numeric ? Number(value) : value,
+            };
+            if (kind === 'duct-fitting' &&
+                key === 'fittingType' &&
+                ['reducer', 'transition'].includes(value)) {
+                defaults.inletShape = value === 'reducer' ? 'round' : 'rect';
+                defaults.outletShape = 'round';
+            }
+            if (kind === 'duct-fitting' && defaults.fittingType === 'transition') {
+                const inlet = defaults.inletShape ?? 'rect';
+                const outlet = defaults.outletShape ?? 'round';
+                if (inlet === outlet) {
+                    if (key === 'outletShape')
+                        defaults.inletShape = outlet === 'round' ? 'rect' : 'round';
+                    else
+                        defaults.outletShape = inlet === 'round' ? 'rect' : 'round';
+                }
+            }
+            if (defaults.fittingType === 'reducer') {
+                const inlet = Number(defaults.diameter ?? (kind === 'duct-fitting' ? 12 : 2));
+                const outlet = Number(defaults.diameter2 ?? inlet);
+                defaults.diameter2 = reducerOutletDiameter(kind, inlet, outlet);
+            }
+            if (kind === 'duct-fitting' && key === 'shape')
+                defaults.shape2 = value;
+            useEditor.getState().setToolDefaults(kind, defaults);
+        },
+        ...(types
+            ? {
+                visible: {
+                    subscribe: (callback) => useEditor.subscribe(callback),
+                    value: () => types.includes(String(useEditor.getState().toolDefaults[kind]?.fittingType ?? 'elbow')),
+                },
+            }
+            : {}),
+    };
+}
+export const ductFittingToolOptions = [
+    option('duct-fitting', 'fittingType', 'Duct fittings & accessories', ['elbow', 'tee', 'cross', 'reducer', 'transition', 'end-cap', 'damper', 'access-panel'], 'elbow'),
+    option('duct-fitting', 'shape', 'Profile', ['round', 'rect', 'oval'], 'rect', false, [
+        'elbow',
+        'tee',
+        'cross',
+        'end-cap',
+        'damper',
+    ]),
+    option('duct-fitting', 'inletShape', 'Inlet profile', ['round', 'rect', 'oval'], 'rect', false, [
+        'transition',
+        'reducer',
+    ]),
+    option('duct-fitting', 'outletShape', 'Outlet profile', ['round', 'rect', 'oval'], 'round', false, ['transition', 'reducer']),
+    {
+        ...option('duct-fitting', 'width2', 'Outlet width (in)', ['8', '10', '14', '20', '24'], '14', true, ['transition', 'reducer']),
+        id: 'outletWidth',
+    },
+    {
+        ...option('duct-fitting', 'height2', 'Outlet height (in)', ['4', '6', '8', '12', '16'], '8', true, ['transition', 'reducer']),
+        id: 'outletHeight',
+    },
+    option('duct-fitting', 'diameter', 'Diameter (in)', ['4', '6', '8', '10', '12'], '12', true),
+    option('duct-fitting', 'width', 'Width (in)', ['8', '10', '14', '20', '24'], '14', true),
+    option('duct-fitting', 'height', 'Height (in)', ['4', '6', '8', '12', '16'], '8', true),
+    option('duct-fitting', 'diameter2', 'Outlet diameter (in)', ['2', '4', '6', '8', '10', '12'], '12', true, ['reducer', 'transition']),
+    {
+        ...option('duct-fitting', 'diameter2', 'Branch diameter (in)', ['2', '4', '6', '8', '10', '12'], '12', true, ['tee', 'cross']),
+        id: 'branchDiameter',
+    },
+    option('duct-fitting', 'shape2', 'Branch profile', ['round', 'rect', 'oval'], 'rect', false, [
+        'tee',
+        'cross',
+    ]),
+    option('duct-fitting', 'width2', 'Branch width (in)', ['8', '10', '14', '20', '24'], '14', true, [
+        'tee',
+        'cross',
+    ]),
+    option('duct-fitting', 'height2', 'Branch height (in)', ['4', '6', '8', '12', '16'], '8', true, [
+        'tee',
+        'cross',
+    ]),
+    option('duct-fitting', 'damperAngle', 'Blade opening (°)', ['0', '45', '90'], '0', true, [
+        'damper',
+    ]),
+    option('duct-fitting', 'panelWidth', 'Access door width (m)', ['0.15', '0.25', '0.4'], '0.25', true, ['access-panel']),
+    option('duct-fitting', 'panelHeight', 'Access door height (m)', ['0.1', '0.15', '0.25'], '0.15', true, ['access-panel']),
+];
+export const pipeFittingToolOptions = [
+    option('pipe-fitting', 'fittingType', 'Pipe fittings & accessories', ['elbow', 'wye', 'sanitary-tee', 'cross', 'end-cap', 'cleanout', 'reducer', 'coupling'], 'elbow'),
+    option('pipe-fitting', 'diameter', 'Diameter (in)', ['1.25', '1.5', '2', '3', '4', '6', '8'], '2', true),
+    option('pipe-fitting', 'diameter2', 'Outlet diameter (in)', ['1.25', '1.5', '2', '3', '4', '6', '8'], '2', true, ['reducer']),
+    {
+        ...option('pipe-fitting', 'diameter2', 'Branch diameter (in)', ['1.25', '1.5', '2', '3', '4', '6', '8'], '2', true, ['wye', 'sanitary-tee', 'cross']),
+        id: 'branchDiameter',
+    },
+    option('pipe-fitting', 'cleanoutStyle', 'Cleanout style', ['end', 'inline'], 'end', false, [
+        'cleanout',
+    ]),
+    option('pipe-fitting', 'pipeMaterial', 'Material', ['pvc', 'abs', 'cast-iron'], 'pvc'),
+];
+for (const entry of ductFittingToolOptions) {
+    if (!['diameter', 'width', 'height'].includes(entry.id))
+        continue;
+    entry.visible = {
+        subscribe: (callback) => useEditor.subscribe(callback),
+        value: () => {
+            const defaults = useEditor.getState().toolDefaults['duct-fitting'];
+            const type = defaults?.fittingType ?? 'elbow';
+            if (type === 'access-panel')
+                return false;
+            const round = ['reducer', 'transition'].includes(String(type))
+                ? (defaults?.inletShape ?? (type === 'reducer' ? 'round' : 'rect')) === 'round'
+                : defaults?.shape === 'round';
+            return entry.id === 'diameter' ? round : !round;
+        },
+    };
+}
+for (const entry of ductFittingToolOptions) {
+    if (!['branchDiameter', 'shape2', 'width2', 'height2'].includes(entry.id))
+        continue;
+    entry.visible = {
+        subscribe: (callback) => useEditor.subscribe(callback),
+        value: () => {
+            const defaults = useEditor.getState().toolDefaults['duct-fitting'];
+            if (!['tee', 'cross'].includes(String(defaults?.fittingType)))
+                return false;
+            const roundRun = defaults?.shape === 'round';
+            const roundBranch = roundRun || defaults?.shape2 === 'round';
+            if (entry.id === 'shape2')
+                return !roundRun;
+            return entry.id === 'branchDiameter' ? roundBranch : !roundBranch;
+        },
+    };
+}
+for (const entry of ductFittingToolOptions) {
+    if (!['diameter2', 'outletWidth', 'outletHeight'].includes(entry.id))
+        continue;
+    entry.visible = {
+        subscribe: (callback) => useEditor.subscribe(callback),
+        value: () => {
+            const defaults = useEditor.getState().toolDefaults['duct-fitting'];
+            if (!['reducer', 'transition'].includes(String(defaults?.fittingType)))
+                return false;
+            const round = (defaults?.outletShape ?? 'round') === 'round';
+            return entry.id === 'diameter2' ? round : !round;
+        },
+    };
+}

package/dist/shared/floor-placement.d.ts

@@ -1,7 +1,7 @@
 import { type AnyNode, type GridEvent, type NodeEvent, resolveAlignment } from '@pascal-app/core';
 export declare const FLOOR_PLACEMENT_ALIGNMENT_THRESHOLD_M = 0.08;
-export declare const FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS: readonly ["shelf", "item", "slab", "ceiling", "wall", "fence", "column", "roof", "roof-segment", "stair", "stair-segment"];
 export type FloorPlacementClickTriggerEvent = GridEvent | NodeEvent<AnyNode>;
+export declare function isForcePlacementEvent(event: FloorPlacementClickTriggerEvent): boolean;
 type FloorPlacementAlignmentArgs = {
     node: AnyNode;
     rawX: number;

package/dist/shared/floor-placement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floor-placement.d.ts","sourceRoot":"","sources":["../../src/shared/floor-placement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,SAAS,EAEd,KAAK,SAAS,EACd,gBAAgB,EAGjB,MAAM,kBAAkB,CAAA;AAGzB,eAAO,MAAM,qCAAqC,OAAO,CAAA;AAEzD,eAAO,MAAM,mCAAmC,4HAYtC,CAAA;AAEV,MAAM,MAAM,+BAA+B,GAAG,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,CAAA;AAE5E,KAAK,2BAA2B,GAAG;IACjC,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAA;IAChE,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAID,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,+BAA+B,EACtC,QAAQ,EAAE,MAAM,EAChB,UAAU,UAAQ,GACjB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAiB1B;AAED,wBAAgB,4BAA4B,CAAC,EAC3C,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,aAAoB,EACpB,kBAAyB,EACzB,UAAkB,EAClB,SAAa,GACd,EAAE,2BAA2B;cAoBD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;;EAGpD;AAgBD,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,+BAA+B,QAUpF;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,CAAC,KAAK,EAAE,+BAA+B,KAAK,IAAI,cAiB1D;AAED,wBAAgB,mCAAmC,CACjD,aAAa,EAAE,CAAC,KAAK,EAAE,+BAA+B,KAAK,IAAI,cAiBhE"}
+{"version":3,"file":"floor-placement.d.ts","sourceRoot":"","sources":["../../src/shared/floor-placement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,SAAS,EAEd,KAAK,SAAS,EACd,gBAAgB,EAGjB,MAAM,kBAAkB,CAAA;AAGzB,eAAO,MAAM,qCAAqC,OAAO,CAAA;AAEzD,MAAM,MAAM,+BAA+B,GAAG,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,CAAA;AAE5E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,+BAA+B,GAAG,OAAO,CAErF;AAED,KAAK,2BAA2B,GAAG;IACjC,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAA;IAChE,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAID,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,+BAA+B,EACtC,QAAQ,EAAE,MAAM,EAChB,UAAU,UAAQ,GACjB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAmB1B;AAED,wBAAgB,4BAA4B,CAAC,EAC3C,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,aAAoB,EACpB,kBAAyB,EACzB,UAAkB,EAClB,SAAa,GACd,EAAE,2BAA2B;cAoBD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;;EAGpD;AAgBD,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,+BAA+B,QAUpF;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,CAAC,KAAK,EAAE,+BAA+B,KAAK,IAAI,cAS1D;AAED,wBAAgB,mCAAmC,CACjD,aAAa,EAAE,CAAC,KAAK,EAAE,+BAA+B,KAAK,IAAI,cAShE"}

package/dist/shared/floor-placement.js

@@ -1,19 +1,9 @@
 import { emitter, movingFootprintAnchors, resolveAlignment, sceneRegistry, snapPointToGrid, } from '@pascal-app/core';
 import { Vector3 } from 'three';
 export const FLOOR_PLACEMENT_ALIGNMENT_THRESHOLD_M = 0.08;
-export const FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS = [
-    'shelf',
-    'item',
-    'slab',
-    'ceiling',
-    'wall',
-    'fence',
-    'column',
-    'roof',
-    'roof-segment',
-    'stair',
-    'stair-segment',
-];
+export function isForcePlacementEvent(event) {
+    return event.nativeEvent?.altKey === true;
+}
 const worldVector = new Vector3();
 export function getLevelLocalSnappedPosition(levelId, event, gridStep, bypassGrid = false) {
     const levelObject = sceneRegistry.nodes.get(levelId);
@@ -26,11 +16,13 @@ export function getLevelLocalSnappedPosition(levelId, event, gridStep, bypassGri
     }
     worldVector.set(event.position[0], event.position[1], event.position[2]);
     levelObject.updateWorldMatrix(true, false);
+    if (!bypassGrid) {
+        const [sx, sz] = snapPointToGrid([worldVector.x, worldVector.z], gridStep);
+        worldVector.x = sx;
+        worldVector.z = sz;
+    }
     levelObject.worldToLocal(worldVector);
-    const [sx, sz] = bypassGrid
-        ? [worldVector.x, worldVector.z]
-        : snapPointToGrid([worldVector.x, worldVector.z], gridStep);
-    return [sx, 0, sz];
+    return [worldVector.x, 0, worldVector.z];
 }
 export function resolveAlignedFloorPlacement({ node, rawX, rawZ, gridStep, candidates, showAlignment = true, applyAlignmentSnap = true, bypassGrid = false, rotationY = 0, }) {
     const [sx, sz] = bypassGrid ? [rawX, rawZ] : snapPointToGrid([rawX, rawZ], gridStep);
@@ -81,29 +73,17 @@ export function stopPlacementCommitPropagation(event) {
 }
 export function subscribeFloorPlacementClicks(onClick) {
     emitter.on('grid:click', onClick);
-    for (const kind of FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS) {
-        const key = `${kind}:click`;
-        emitter.on(key, onClick);
-    }
+    emitter.on('node:click', onClick);
     return () => {
         emitter.off('grid:click', onClick);
-        for (const kind of FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS) {
-            const key = `${kind}:click`;
-            emitter.off(key, onClick);
-        }
+        emitter.off('node:click', onClick);
     };
 }
 export function subscribeFloorPlacementDoubleClicks(onDoubleClick) {
     emitter.on('grid:double-click', onDoubleClick);
-    for (const kind of FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS) {
-        const key = `${kind}:double-click`;
-        emitter.on(key, onDoubleClick);
-    }
+    emitter.on('node:double-click', onDoubleClick);
     return () => {
         emitter.off('grid:double-click', onDoubleClick);
-        for (const kind of FLOOR_PLACEMENT_CLICK_TRIGGER_KINDS) {
-            const key = `${kind}:double-click`;
-            emitter.off(key, onDoubleClick);
-        }
+        emitter.off('node:double-click', onDoubleClick);
     };
 }

package/dist/shared/ghost-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ghost-materials.d.ts","sourceRoot":"","sources":["../../src/shared/ghost-materials.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,QAAQ,EAAa,MAAM,OAAO,CAAA;AAEhE,eAAO,MAAM,mBAAmB,WAAa,CAAA;AAC7C,eAAO,MAAM,iBAAiB,UAAa,CAAA;AAI3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,EACd,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAC5C,MAAM,IAAI,CAuDZ"}
+{"version":3,"file":"ghost-materials.d.ts","sourceRoot":"","sources":["../../src/shared/ghost-materials.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAkB,QAAQ,EAAa,MAAM,OAAO,CAAA;AAEhE,eAAO,MAAM,mBAAmB,WAAa,CAAA;AAC7C,eAAO,MAAM,iBAAiB,UAAa,CAAA;AAO3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,EACd,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAC5C,MAAM,IAAI,CAuDZ"}

package/dist/shared/ghost-materials.js

@@ -1,7 +1,8 @@
 'use client';
+import { markPureRaycast } from '@pascal-app/viewer';
 export const INVALID_GHOST_COLOR = 0xef_44_44;
 export const VALID_GHOST_COLOR = 0x22_c5_5e;
-const NO_RAYCAST = (_raycaster, _intersects) => { };
+const NO_RAYCAST = markPureRaycast(function NO_RAYCAST(_raycaster, _intersects) { });
 /**
  * Apply ghost material treatment to a preview mesh tree.
  *

package/dist/shared/lean-to-post-omissions.d.ts

@@ -0,0 +1,8 @@
+import type { AnyNode, AnyNodeId, ColumnNode, LeanToExtensionNode } from '@pascal-app/core';
+import type { LeanToPostSide } from '../lean-to-extension/assembly';
+export declare function isLeanToPostOmitted(leanTo: LeanToExtensionNode, side: LeanToPostSide, index: number): boolean;
+export declare function leanToPostOmissionPatchesOnDelete(column: ColumnNode, nodes: Record<AnyNodeId, AnyNode>): Array<{
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+}>;
+//# sourceMappingURL=lean-to-post-omissions.d.ts.map

package/dist/shared/lean-to-post-omissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lean-to-post-omissions.d.ts","sourceRoot":"","sources":["../../src/shared/lean-to-post-omissions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAC3F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAgBnE,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,MAAM,GACZ,OAAO,CAYT;AAED,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAmBlD"}