@pascal-app/nodes 0.1.1

package/dist/shared/placeholder-geometry.d.ts

@@ -0,0 +1,22 @@
+import { BufferGeometry } from 'three';
+/**
+ * Placeholder geometry for a mesh whose real geometry is filled in later by a
+ * system (wall / roof / roof-segment / ceiling / stair-segment). These meshes
+ * are mounted *visible*, so the WebGPU renderer draws them on the first
+ * frame(s) before the owning system runs — and the system passes are
+ * rate-limited, so several meshes can still hold the placeholder across
+ * multiple frames.
+ *
+ * It carries three zero-vertices — a single degenerate, zero-area (invisible)
+ * triangle — rather than an empty `position` attribute. An empty attribute
+ * (count 0) makes three.js create no GPU buffer for it, so vertex buffer slot 0
+ * is never bound and WebGPU rejects the draw with "Vertex buffer slot 0 … was
+ * not set", which poisons the whole command encoder (cascading into "Invalid
+ * CommandBuffer" on every queue submit). The zero normals and UVs keep lit
+ * node-material pipelines from compiling additional required-but-unbound
+ * vertex buffers. Three real vertices give it bound buffers; the `groupCount`
+ * count-0 groups keep nothing drawn while matching the mesh's material-array
+ * length so raycasts / BVH never index past the materials.
+ */
+export declare function createPlaceholderGeometry(groupCount?: number): BufferGeometry;
+//# sourceMappingURL=placeholder-geometry.d.ts.map

package/dist/shared/placeholder-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeholder-geometry.d.ts","sourceRoot":"","sources":["../../src/shared/placeholder-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAA0B,MAAM,OAAO,CAAA;AAE9D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,SAAI,GAAG,cAAc,CAUxE"}

package/dist/shared/placeholder-geometry.js

@@ -0,0 +1,31 @@
+import { BufferGeometry, Float32BufferAttribute } from 'three';
+/**
+ * Placeholder geometry for a mesh whose real geometry is filled in later by a
+ * system (wall / roof / roof-segment / ceiling / stair-segment). These meshes
+ * are mounted *visible*, so the WebGPU renderer draws them on the first
+ * frame(s) before the owning system runs — and the system passes are
+ * rate-limited, so several meshes can still hold the placeholder across
+ * multiple frames.
+ *
+ * It carries three zero-vertices — a single degenerate, zero-area (invisible)
+ * triangle — rather than an empty `position` attribute. An empty attribute
+ * (count 0) makes three.js create no GPU buffer for it, so vertex buffer slot 0
+ * is never bound and WebGPU rejects the draw with "Vertex buffer slot 0 … was
+ * not set", which poisons the whole command encoder (cascading into "Invalid
+ * CommandBuffer" on every queue submit). The zero normals and UVs keep lit
+ * node-material pipelines from compiling additional required-but-unbound
+ * vertex buffers. Three real vertices give it bound buffers; the `groupCount`
+ * count-0 groups keep nothing drawn while matching the mesh's material-array
+ * length so raycasts / BVH never index past the materials.
+ */
+export function createPlaceholderGeometry(groupCount = 0) {
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(new Float32Array(9), 3));
+    geometry.setAttribute('normal', new Float32BufferAttribute(new Float32Array(9), 3));
+    geometry.setAttribute('uv', new Float32BufferAttribute(new Float32Array(6), 2));
+    geometry.setAttribute('uv2', new Float32BufferAttribute(new Float32Array(6), 2));
+    for (let group = 0; group < groupCount; group++) {
+        geometry.addGroup(0, 0, group);
+    }
+    return geometry;
+}

package/dist/shared/polygon-centroid-move.d.ts

@@ -0,0 +1,21 @@
+import { type AnyNode, type AnyNodeId, type FloorplanMoveTargetSession } from '@pascal-app/core';
+export declare function createPolygonCentroidMoveTarget(args: {
+    node: {
+        id: string;
+        type: string;
+        polygon: Array<[number, number]>;
+        holes?: Array<Array<[number, number]>>;
+        metadata?: unknown;
+    };
+    nodes: Record<AnyNodeId, AnyNode>;
+    /** 3D mesh Y the kind's system parks the group at on rebuild. */
+    meshY: number;
+    /**
+     * Extra fields merged into the commit payload. Use for kind-specific flags
+     * that a manual drag should clear — e.g. slab `autoFromWalls: false`, so the
+     * space-detection sync stops re-deriving the polygon from walls and
+     * snapping the slab back to its original position.
+     */
+    extraCommitData?: Record<string, unknown>;
+}): FloorplanMoveTargetSession;
+//# sourceMappingURL=polygon-centroid-move.d.ts.map

package/dist/shared/polygon-centroid-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-centroid-move.d.ts","sourceRoot":"","sources":["../../src/shared/polygon-centroid-move.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,KAAK,0BAA0B,EAMhC,MAAM,kBAAkB,CAAA;AAqDzB,wBAAgB,+BAA+B,CAAC,IAAI,EAAE;IACpD,IAAI,EAAE;QACJ,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;QAChC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;QACtC,QAAQ,CAAC,EAAE,OAAO,CAAA;KACnB,CAAA;IACD,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAA;IACb;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC1C,GAAG,0BAA0B,CAiF7B"}

package/dist/shared/polygon-centroid-move.js

@@ -0,0 +1,117 @@
+import { collectAlignmentAnchors, polygonAnchors, resolveAlignment, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { getSegmentGridStep, isMagneticSnapActive, useAlignmentGuides, } from '@pascal-app/editor';
+import { createFloorplanCursorResolver } from './floorplan-cursor';
+/**
+ * Shared 2D floor-plan move for polygon-based kinds (slab / ceiling / zone).
+ *
+ * Existing polygon kinds preserve the cursor grab offset; fresh catalog
+ * placement uses the polygon centroid as the cursor-following pivot. This
+ * matches the generic 3D move tool while keeping polygon geometry in vertices.
+ *
+ * **Why a delta in `useLiveTransforms`** (see `wiki/architecture/tools.md`):
+ * polygon kinds carry their position in their vertices, not a `position`
+ * field. The live preview translates the rendered `<group>` by the delta
+ * (`ParametricNodeRenderer` consumes `useLiveTransforms.position` as the
+ * group position) so the SVG follows the EXACT snapped result with no CSG
+ * rebuild per tick. On commit we write the translated polygon once. Because
+ * the live delta and the committed polygon are derived from the same
+ * `lastDelta`, the visual and the commit always agree.
+ *
+ * `meshY` mirrors the value the kind's system sets on rebuild (slab: 0;
+ * ceiling: `height − 0.01`) so the 3D mesh doesn't teleport vertically in a
+ * split view during the drag.
+ */
+/** Figma-style alignment threshold (meters) — parity with the 3D move tools. */
+const ALIGNMENT_THRESHOLD_M = 0.08;
+function translatePolygon(polygon, dx, dz) {
+    return polygon.map(([x, z]) => [x + dx, z + dz]);
+}
+/** Average of the polygon's vertices — matches the 3D `MoveSlabTool` pivot. */
+function polygonCentroid(polygon) {
+    if (polygon.length === 0)
+        return [0, 0];
+    let sumX = 0;
+    let sumZ = 0;
+    for (const [x, z] of polygon) {
+        sumX += x;
+        sumZ += z;
+    }
+    return [sumX / polygon.length, sumZ / polygon.length];
+}
+export function createPolygonCentroidMoveTarget(args) {
+    const { node, nodes, meshY, extraCommitData } = args;
+    const id = node.id;
+    const typeGuard = node.type;
+    const originalPolygon = node.polygon.map(([x, z]) => [x, z]);
+    const hasHoles = Array.isArray(node.holes);
+    const originalHoles = (node.holes ?? []).map((hole) => hole.map(([x, z]) => [x, z]));
+    const originalCenter = polygonCentroid(originalPolygon);
+    const resolveCursor = createFloorplanCursorResolver({
+        original: originalCenter,
+        metadata: node.metadata,
+    });
+    // Alignment candidates gathered once — the scene is stable during the drag.
+    const candidates = collectAlignmentAnchors(nodes, id);
+    let lastDelta = [0, 0];
+    return {
+        affectedIds: [id],
+        apply({ planPoint, modifiers }) {
+            // Centroid → snapped cursor. Grid-snap the target centroid (Shift
+            // drops the grid snap), then layer Figma alignment on the translated
+            // polygon's vertices and fold its snap into the delta. Alt bypasses.
+            const step = getSegmentGridStep();
+            const snap = (value) => (modifiers.shiftKey ? value : Math.round(value / step) * step);
+            const target = resolveCursor(planPoint, { snap });
+            let dx = target[0] - originalCenter[0];
+            let dz = target[1] - originalCenter[1];
+            if (!(modifiers.altKey || modifiers.shiftKey) && candidates.length > 0) {
+                const result = resolveAlignment({
+                    moving: polygonAnchors(id, translatePolygon(originalPolygon, dx, dz)),
+                    candidates,
+                    threshold: ALIGNMENT_THRESHOLD_M,
+                });
+                if (result.snap && isMagneticSnapActive()) {
+                    dx += result.snap.dx;
+                    dz += result.snap.dz;
+                }
+                useAlignmentGuides.getState().set(result.guides);
+            }
+            else {
+                useAlignmentGuides.getState().clear();
+            }
+            lastDelta = [dx, dz];
+            // Live-drag exception: write the delta to BOTH `useLiveTransforms`
+            // (React source of truth) and the mesh (direct Three.js) so they don't
+            // fight per frame.
+            useLiveTransforms.getState().set(id, { position: [dx, 0, dz], rotation: 0 });
+            const mesh = sceneRegistry.nodes.get(id);
+            if (mesh)
+                mesh.position.set(dx, meshY, dz);
+        },
+        canCommit() {
+            const live = useScene.getState().nodes[id];
+            if (!live || live.type !== typeGuard)
+                return false;
+            const [dx, dz] = lastDelta;
+            if (dx === 0 && dz === 0)
+                return false;
+            // Sync commit: scene write → direct markDirty → clear live transform,
+            // so the React render and the kind's geometry rebuild land in the same
+            // paint (no original-position blink). Only write `holes` for kinds that
+            // have them (zone has none).
+            const data = {
+                polygon: translatePolygon(originalPolygon, dx, dz),
+            };
+            if (hasHoles) {
+                data.holes = originalHoles.map((h) => translatePolygon(h, dx, dz));
+            }
+            if (extraCommitData) {
+                Object.assign(data, extraCommitData);
+            }
+            useScene.getState().updateNodes([{ id, data }]);
+            useScene.getState().markDirty(id);
+            useLiveTransforms.getState().clear(id);
+            return true;
+        },
+    };
+}

package/dist/shared/polygon-measurement.d.ts

@@ -0,0 +1,10 @@
+import type { MeasurementFeature } from '@pascal-app/core';
+type PolygonPoint = readonly [number, number];
+export declare function polygonMeasurementFeatures({ featurePrefix, height, label, polygon, }: {
+    featurePrefix: string;
+    height: number;
+    label: string;
+    polygon: readonly PolygonPoint[];
+}): MeasurementFeature[];
+export {};
+//# sourceMappingURL=polygon-measurement.d.ts.map

package/dist/shared/polygon-measurement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-measurement.d.ts","sourceRoot":"","sources":["../../src/shared/polygon-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAoB,MAAM,kBAAkB,CAAA;AAE5E,KAAK,YAAY,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAQ7C,wBAAgB,0BAA0B,CAAC,EACzC,aAAa,EACb,MAAM,EACN,KAAK,EACL,OAAO,GACR,EAAE;IACD,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,SAAS,YAAY,EAAE,CAAA;CACjC,GAAG,kBAAkB,EAAE,CA+BvB"}

package/dist/shared/polygon-measurement.js

@@ -0,0 +1,35 @@
+function polygonCenter(polygon, height) {
+    if (polygon.length === 0)
+        return [0, height, 0];
+    const [x, z] = polygon.reduce(([sumX, sumZ], point) => [sumX + point[0], sumZ + point[1]], [0, 0]);
+    return [x / polygon.length, height, z / polygon.length];
+}
+export function polygonMeasurementFeatures({ featurePrefix, height, label, polygon, }) {
+    const points = polygon.map(([x, z]) => [x, height, z]);
+    return [
+        ...points.map((point, index) => ({
+            id: `${featurePrefix}:vertex:${index}`,
+            label: `${label} corner`,
+            snapKind: 'endpoint',
+            priority: 110,
+            normal: [0, 1, 0],
+            geometry: { kind: 'point', point },
+        })),
+        {
+            id: `${featurePrefix}:boundary`,
+            label: `${label} boundary`,
+            snapKind: 'edge',
+            priority: 90,
+            normal: [0, 1, 0],
+            geometry: { kind: 'polygon', points },
+        },
+        {
+            id: `${featurePrefix}:center`,
+            label: `${label} center`,
+            snapKind: 'center',
+            priority: 70,
+            normal: [0, 1, 0],
+            geometry: { kind: 'point', point: polygonCenter(polygon, height) },
+        },
+    ];
+}

package/dist/shared/polygon-vertex-affordance.d.ts

@@ -0,0 +1,108 @@
+import { type AnyNode, type AnyNodeId, type FloorplanAffordance, type FloorplanAffordanceModifiers } from '@pascal-app/core';
+import { type WallPlanPoint } from '@pascal-app/editor';
+/**
+ * Shared "edit polygon" floor-plan affordances. Used by kinds whose
+ * primary editable shape is a `polygon: [number, number][]` field
+ * (slab, ceiling, site, zone) with optional `holes: [number, number][][]`.
+ *
+ * Each affordance accepts an optional `holeIndex` in its payload — when
+ * present, the operation targets `node.holes[holeIndex]`; otherwise it
+ * targets the outer `node.polygon`. The same factory wires both
+ * boundary and hole interactions without duplicating the math.
+ *
+ * Four affordances available:
+ *
+ * - `move-vertex` — drag an existing vertex.
+ * - `add-vertex` — insert a new vertex at an edge midpoint, then drag
+ *   it (click-without-drag reverts to the snapshot).
+ * - `move-edge` — drag a whole edge perpendicular to itself (both
+ *   endpoints translate by `normal * projection`).
+ * - `delete-vertex` — remove a double-clicked vertex while preserving
+ *   the minimum three-vertex ring.
+ */
+export type PolygonVertexPayload = {
+    /** Target a hole's polygon instead of the boundary. */
+    holeIndex?: number;
+    vertexIndex: number;
+};
+export type AddVertexPayload = {
+    holeIndex?: number;
+    edgeIndex: number;
+};
+export type EdgeDragPayload = {
+    holeIndex?: number;
+    edgeIndex: number;
+};
+type PolygonAffordanceMode = 'move-vertex' | 'add-vertex' | 'move-edge';
+export type PolygonAffordanceSnapContext<N extends PolygonShape & {
+    id: AnyNodeId;
+}> = {
+    node: N;
+    nodes: Record<AnyNodeId, AnyNode>;
+    rawPoint: WallPlanPoint;
+    fallbackPoint: WallPlanPoint;
+    modifiers: FloorplanAffordanceModifiers;
+    holeIndex?: number;
+    mode: PolygonAffordanceMode;
+};
+export type PolygonEdgeSnapContext<N extends PolygonShape & {
+    id: AnyNodeId;
+}> = {
+    node: N;
+    nodes: Record<AnyNodeId, AnyNode>;
+    /** Candidate edge (after the perpendicular translation), in ring order. */
+    edge: [[number, number], [number, number]];
+    rawPoint: WallPlanPoint;
+    modifiers: FloorplanAffordanceModifiers;
+    holeIndex?: number;
+};
+export type PolygonAffordanceOptions<N extends PolygonShape & {
+    id: AnyNodeId;
+}> = {
+    /** Data committed only when the outer boundary (not a hole) is edited. */
+    boundaryCommitData?: Partial<N>;
+    resolvePlanPoint?: (context: PolygonAffordanceSnapContext<N>) => WallPlanPoint;
+    /**
+     * `move-edge` only: absolute edge snap. The point-based resolver runs
+     * on the CURSOR, so any grab offset between the pointer and the edge
+     * line gets baked into a point snap; an edge that must land exactly on
+     * a target line (wall centerline) snaps here instead — return the
+     * translated edge, or `null` to keep the candidate.
+     */
+    snapEdge?: (context: PolygonEdgeSnapContext<N>) => [[number, number], [number, number]] | null;
+};
+type PolygonShape = {
+    polygon: ReadonlyArray<readonly [number, number]>;
+    holes?: ReadonlyArray<ReadonlyArray<readonly [number, number]>>;
+};
+export declare function createPolygonVertexAffordance<N extends PolygonShape & {
+    id: AnyNodeId;
+}>(kind: string, options?: PolygonAffordanceOptions<N>): FloorplanAffordance<N>;
+/**
+ * Companion to `createPolygonVertexAffordance`. Inserts a new vertex at
+ * the midpoint of edge `edgeIndex` (between vertices i and i+1) and
+ * then drags that new vertex with the pointer. The dispatcher's
+ * snapshot was taken **before** `start()` ran, so a pointer-up without
+ * movement reverts to the pre-insert ring — "click without drag" is a
+ * no-op, matching the legacy slab boundary editor.
+ */
+export declare function createPolygonAddVertexAffordance<N extends PolygonShape & {
+    id: AnyNodeId;
+}>(kind: string, options?: PolygonAffordanceOptions<N>): FloorplanAffordance<N>;
+export declare function createPolygonDeleteVertexAffordance<N extends PolygonShape & {
+    id: AnyNodeId;
+}>(kind: string, options?: PolygonAffordanceOptions<N>): FloorplanAffordance<N>;
+/**
+ * Edge-drag: move a whole edge perpendicular to itself. Both endpoints
+ * translate by `edgeNormal * projectedDelta`. The other vertices of
+ * the ring stay put — adjacent edges effectively pivot around their
+ * far endpoints.
+ *
+ * Snap is grid-aligned on the projected scalar (so a Shift-free drag
+ * lands on grid lines along the edge normal).
+ */
+export declare function createPolygonMoveEdgeAffordance<N extends PolygonShape & {
+    id: AnyNodeId;
+}>(kind: string, options?: PolygonAffordanceOptions<N>): FloorplanAffordance<N>;
+export {};
+//# sourceMappingURL=polygon-vertex-affordance.d.ts.map

package/dist/shared/polygon-vertex-affordance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-vertex-affordance.d.ts","sourceRoot":"","sources":["../../src/shared/polygon-vertex-affordance.ts"],"names":[],"mappings":"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"}