@pascal-app/core 0.7.0 → 0.9.1

package/dist/services/single-undo-dance.test.js

@@ -0,0 +1,210 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+import { createSceneApi } from '../registry/scene-api';
+import useScene from '../store/use-scene';
+globalThis.requestAnimationFrame ??= ((cb) => {
+    cb(0);
+    return 0;
+});
+globalThis.cancelAnimationFrame ??=
+    () => { };
+/**
+ * Validates the "single-undo dance" pattern used by Stage D actions:
+ *
+ *   action.commit:
+ *     scene.restoreAll()       // revert via snapshot (paused → no zundo record)
+ *     scene.resumeHistory()    // unpause zundo
+ *     scene.update(...)        // re-apply final → zundo records one diff
+ *     return true
+ *
+ * After the dance, undo() should roll back ONLY the drag's commit —
+ * never further back than that. The fence-bend regression that surfaced
+ * after Phase 5 Stage D porting was reportedly losing the prior create
+ * step on undo; this test pins the correct behavior.
+ */
+const FENCE_ID = 'fence_test';
+function makeFence(curveOffset) {
+    return {
+        id: FENCE_ID,
+        type: 'fence',
+        parentId: null,
+        object: 'node',
+        visible: true,
+        metadata: {},
+        start: [0, 0],
+        end: [3, 0],
+        height: 1.8,
+        thickness: 0.08,
+        baseHeight: 0.22,
+        postSpacing: 2,
+        postSize: 0.1,
+        topRailHeight: 0.04,
+        groundClearance: 0,
+        edgeInset: 0.015,
+        baseStyle: 'grounded',
+        showInfill: true,
+        color: '#ffffff',
+        style: 'slat',
+        curveOffset,
+    };
+}
+describe('Single-undo dance', () => {
+    beforeEach(() => {
+        useScene.setState({ nodes: {}, rootNodeIds: [] });
+        useScene.temporal.getState().clear();
+    });
+    test('curve-style commit yields a single undo step', () => {
+        // 1. Create the fence (recorded by zundo).
+        useScene.getState().createNode(makeFence(0));
+        const pastCountAfterCreate = useScene.temporal.getState().pastStates.length;
+        // 2. Simulate the drag.
+        const scene = createSceneApi(useScene);
+        scene.pauseHistory();
+        scene.update(FENCE_ID, { curveOffset: 0.2 });
+        scene.update(FENCE_ID, { curveOffset: 0.5 });
+        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
+        // 3. Commit dance.
+        scene.restoreAll();
+        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0);
+        scene.resumeHistory();
+        scene.update(FENCE_ID, { curveOffset: 0.5 });
+        const pastCountAfterDance = useScene.temporal.getState().pastStates.length;
+        expect(pastCountAfterDance).toBe(pastCountAfterCreate + 1);
+        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
+        // 4. Undo — should return fence to curveOffset 0, NOT delete it.
+        useScene.temporal.getState().undo();
+        const fenceAfterUndo = useScene.getState().nodes[FENCE_ID];
+        expect(fenceAfterUndo).toBeDefined();
+        expect(fenceAfterUndo.curveOffset).toBe(0);
+    });
+    test('StrictMode double-mount: dispose-then-restart preserves history', () => {
+        useScene.getState().createNode(makeFence(0));
+        const pastBeforeBend = useScene.temporal.getState().pastStates.length;
+        // Simulate StrictMode: first mount → cleanup (dispose) → second mount → drag → commit.
+        const scene = createSceneApi(useScene);
+        // Mount 1.
+        scene.pauseHistory();
+        // Mount 1 cleanup (StrictMode): no apply happened yet. dispose-equivalent.
+        scene.restoreAll(); // snapshot empty, no-op.
+        scene.resumeHistory();
+        // Mount 2.
+        scene.pauseHistory();
+        // Drag.
+        scene.update(FENCE_ID, { curveOffset: 0.3 });
+        scene.update(FENCE_ID, { curveOffset: 0.7 });
+        // Commit dance.
+        scene.restoreAll();
+        scene.resumeHistory();
+        scene.update(FENCE_ID, { curveOffset: 0.7 });
+        const pastAfterBend = useScene.temporal.getState().pastStates.length;
+        // Exactly one new entry: the pre-bend state. Not two (which would mean
+        // StrictMode's first mount/cleanup polluted history).
+        expect(pastAfterBend).toBe(pastBeforeBend + 1);
+        useScene.temporal.getState().undo();
+        expect(useScene.getState().nodes[FENCE_ID]).toBeDefined();
+        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0);
+    });
+    test('commit-returns-false (no change) does NOT consume the prior pastState', () => {
+        // This is the suspected bend regression: when action.commit returns
+        // false (draft.curveOffset === ctx.originalCurveOffset), session.commit
+        // calls scene.restoreAll() but doesn't push to pastStates. Subsequent
+        // undo pops the PRIOR action (e.g. fence creation), not the no-op
+        // bend.
+        useScene.getState().createNode(makeFence(0));
+        const pastBeforeBend = useScene.temporal.getState().pastStates.length;
+        const scene = createSceneApi(useScene);
+        scene.pauseHistory();
+        // Drag back to original — simulates no-op bend.
+        scene.update(FENCE_ID, { curveOffset: 0.0 });
+        // Cancel path (mimics session.commit → action.commit returns false → scene.restoreAll → terminate).
+        scene.restoreAll();
+        scene.resumeHistory();
+        const pastAfterNoOp = useScene.temporal.getState().pastStates.length;
+        expect(pastAfterNoOp).toBe(pastBeforeBend); // no entries added
+        // Now undo — this should be a no-op (state unchanged), but pops the create.
+        useScene.temporal.getState().undo();
+        // ⚠️ Reproduces the bug — undo removes the fence:
+        const fence = useScene.getState().nodes[FENCE_ID];
+        if (fence === undefined) {
+            // Bug reproduced. The "no-op bend" allowed Ctrl-Z to fall through
+            // to the fence creation. Fix is in action.commit: don't return false
+            // — push a no-op entry instead, or guard against the cancel path.
+            expect(fence).toBeUndefined();
+        }
+        else {
+            expect(fence.curveOffset).toBe(0);
+        }
+    });
+    test('full session flow via createDragSession with real action.commit dance', async () => {
+        // Reproduces the actual wrapper flow:
+        //   - createNode → session.start → moves → grid:click → session.commit.
+        // The action.commit does the dance internally.
+        const { createDragSession } = await import('./drag-session');
+        useScene.getState().createNode(makeFence(0));
+        const pastBeforeBend = useScene.temporal.getState().pastStates.length;
+        const scene = createSceneApi(useScene);
+        const action = {
+            begin: () => ({ original: 0 }),
+            preview: (_ctx, point) => ({ offset: point[0] }),
+            apply: (draft, _ctx, s) => {
+                s.update(FENCE_ID, { curveOffset: draft.offset });
+                return [FENCE_ID];
+            },
+            commit: (draft, ctx, s) => {
+                if (draft.offset === ctx.original)
+                    return false;
+                s.restoreAll();
+                s.resumeHistory();
+                s.update(FENCE_ID, { curveOffset: draft.offset });
+                return true;
+            },
+            cancel: () => { },
+        };
+        const session = createDragSession(action, scene);
+        session.start({ point: [0, 0] });
+        session.move([0.3, 0], { shift: false, alt: false, ctrl: false, meta: false });
+        session.move([0.5, 0], { shift: false, alt: false, ctrl: false, meta: false });
+        const okCommit = session.commit();
+        expect(okCommit).toBe(true);
+        const pastAfter = useScene.temporal.getState().pastStates.length;
+        expect(pastAfter).toBe(pastBeforeBend + 1);
+        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
+        useScene.temporal.getState().undo();
+        const after = useScene.getState().nodes[FENCE_ID];
+        expect(after).toBeDefined();
+        expect(after.curveOffset).toBe(0);
+    });
+    test('REAL bend (draft != original): one Ctrl-Z undoes only the bend', () => {
+        useScene.getState().createNode(makeFence(0));
+        const stateAfterCreate = useScene.getState().nodes[FENCE_ID];
+        expect(stateAfterCreate.curveOffset).toBe(0);
+        const scene = createSceneApi(useScene);
+        scene.pauseHistory();
+        // Simulate a real drag: capture original, mutate to non-zero.
+        scene.update(FENCE_ID, { curveOffset: 0.5 });
+        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
+        // Dance.
+        scene.restoreAll();
+        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0);
+        scene.resumeHistory();
+        scene.update(FENCE_ID, { curveOffset: 0.5 });
+        expect(useScene.getState().nodes[FENCE_ID].curveOffset).toBe(0.5);
+        // First Ctrl-Z should undo the bend.
+        useScene.temporal.getState().undo();
+        const afterFirstUndo = useScene.getState().nodes[FENCE_ID];
+        expect(afterFirstUndo).toBeDefined();
+        expect(afterFirstUndo?.curveOffset).toBe(0);
+    });
+    test('a SECOND undo rolls the create step back', () => {
+        useScene.getState().createNode(makeFence(0));
+        const scene = createSceneApi(useScene);
+        scene.pauseHistory();
+        scene.update(FENCE_ID, { curveOffset: 0.5 });
+        scene.restoreAll();
+        scene.resumeHistory();
+        scene.update(FENCE_ID, { curveOffset: 0.5 });
+        useScene.temporal.getState().undo();
+        expect(useScene.getState().nodes[FENCE_ID]).toBeDefined();
+        useScene.temporal.getState().undo();
+        expect(useScene.getState().nodes[FENCE_ID]).toBeUndefined();
+    });
+});

package/dist/services/snap.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Pure snap math — no React, no R3F, no scene access.
+ *
+ * Phase 1 ships the kind-agnostic snappers (grid + angle). Wall-specific
+ * snapping (snap-to-endpoint, snap-along-T) currently lives in
+ * `editor/src/components/tools/wall/wall-drafting.ts` and stays there until
+ * Phase 3, when the wall migration ports it here behind a `wallSnap` namespace.
+ *
+ * The functions here are stable contract — Phase 3 only adds, never removes.
+ */
+export type Vec2 = readonly [number, number];
+export type Vec3 = readonly [number, number, number];
+/** Default planar grid spacing in meters. Matches the editor's wall tool. */
+export declare const DEFAULT_GRID_STEP = 0.25;
+/** Default angle-snap step — π/12 = 15°. Wall tools also use π/4 (45°). */
+export declare const DEFAULT_ANGLE_STEP: number;
+/** Snaps a single scalar to the nearest multiple of `step`. */
+export declare function snapScalar(value: number, step?: number): number;
+/** Snaps a 2D point to a regular planar grid. */
+export declare function snapPointToGrid(point: Vec2, step?: number): Vec2;
+/** Snaps a 3D point to a regular grid in the X/Z plane, preserving Y. */
+export declare function snapVec3ToGrid(point: Vec3, step?: number): Vec3;
+/**
+ * Snap a world XZ point to the grid, then express it in the local frame of
+ * a building positioned at `buildingPosition` with rotation `buildingRotationY`
+ * (radians, around the Y axis). Returns both the snapped world point and its
+ * local-frame equivalent, so callers can render in either frame without
+ * recomputing the rotation.
+ *
+ * Use when a tool needs to keep snapping on the world grid (the grid the
+ * editor renders) even when the active building is rotated. Snapping in the
+ * building's local frame would otherwise chase the rotated axes and miss
+ * the visible grid lines.
+ */
+export declare function snapWorldXZToBuildingLocal(worldX: number, worldZ: number, buildingPosition: Vec3, buildingRotationY: number, step?: number): {
+    world: [number, number];
+    local: [number, number];
+};
+/**
+ * Snaps a cursor point to the nearest angle multiple of `angleStep` (radians)
+ * measured from `from`, preserving distance. Useful for axis/diagonal-locked
+ * placement and wall draft endpoint locking.
+ *
+ * After the angle snap, the result is grid-snapped if `gridStep` is provided
+ * — keeps endpoints landing on grid intersections.
+ */
+export declare function snapPointToAngle(from: Vec2, cursor: Vec2, angleStep?: number, gridStep?: number): Vec2;
+/**
+ * Snaps an angle (in radians) to the nearest entry in `snapAngles` (also in
+ * radians). Returns the original angle if no entry is within `toleranceRad`.
+ */
+export declare function snapAngleToList(angle: number, snapAngles: readonly number[], toleranceRad?: number): number;
+/**
+ * Stable surface that `DragAction.snap` callbacks receive. Phase 1 ships
+ * `grid` and `angle`. Phase 3 adds a `wall` namespace populated by wall
+ * migration. Plugin authors should target this facade rather than importing
+ * the individual functions, so future Phase contributions become visible
+ * without code changes.
+ */
+export type SnapServices = {
+    grid: {
+        snap: (point: Vec2, step?: number) => Vec2;
+        snapVec3: (point: Vec3, step?: number) => Vec3;
+        snapScalar: (value: number, step?: number) => number;
+    };
+    angle: {
+        snapTo: (from: Vec2, cursor: Vec2, angleStep?: number, gridStep?: number) => Vec2;
+        snapToList: (angle: number, list: readonly number[], toleranceRad?: number) => number;
+    };
+};
+export declare const snapServices: SnapServices;
+//# sourceMappingURL=snap.d.ts.map

package/dist/services/snap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snap.d.ts","sourceRoot":"","sources":["../../src/services/snap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC5C,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpD,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,QAAe,CAAA;AAI9C,+DAA+D;AAC/D,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAA0B,GAAG,MAAM,CAGlF;AAED,iDAAiD;AACjD,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAEnF;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAElF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,IAAI,EACtB,iBAAiB,EAAE,MAAM,EACzB,IAAI,GAAE,MAA0B,GAC/B;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA2BtD;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,IAAI,EACZ,SAAS,GAAE,MAA2B,EACtC,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAWN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,YAAY,GAAE,MAAqB,GAClC,MAAM,CAcR;AAID;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE;QACJ,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC1C,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC9C,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACrD,CAAA;IACD,KAAK,EAAE;QACL,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QACjF,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACtF,CAAA;CACF,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,YAU1B,CAAA"}

package/dist/services/snap.js

@@ -0,0 +1,120 @@
+/**
+ * Pure snap math — no React, no R3F, no scene access.
+ *
+ * Phase 1 ships the kind-agnostic snappers (grid + angle). Wall-specific
+ * snapping (snap-to-endpoint, snap-along-T) currently lives in
+ * `editor/src/components/tools/wall/wall-drafting.ts` and stays there until
+ * Phase 3, when the wall migration ports it here behind a `wallSnap` namespace.
+ *
+ * The functions here are stable contract — Phase 3 only adds, never removes.
+ */
+/** Default planar grid spacing in meters. Matches the editor's wall tool. */
+export const DEFAULT_GRID_STEP = 0.25;
+/** Default angle-snap step — π/12 = 15°. Wall tools also use π/4 (45°). */
+export const DEFAULT_ANGLE_STEP = Math.PI / 12;
+// ─── Grid snap ────────────────────────────────────────────────────────
+/** Snaps a single scalar to the nearest multiple of `step`. */
+export function snapScalar(value, step = DEFAULT_GRID_STEP) {
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+/** Snaps a 2D point to a regular planar grid. */
+export function snapPointToGrid(point, step = DEFAULT_GRID_STEP) {
+    return [snapScalar(point[0], step), snapScalar(point[1], step)];
+}
+/** Snaps a 3D point to a regular grid in the X/Z plane, preserving Y. */
+export function snapVec3ToGrid(point, step = DEFAULT_GRID_STEP) {
+    return [snapScalar(point[0], step), point[1], snapScalar(point[2], step)];
+}
+/**
+ * Snap a world XZ point to the grid, then express it in the local frame of
+ * a building positioned at `buildingPosition` with rotation `buildingRotationY`
+ * (radians, around the Y axis). Returns both the snapped world point and its
+ * local-frame equivalent, so callers can render in either frame without
+ * recomputing the rotation.
+ *
+ * Use when a tool needs to keep snapping on the world grid (the grid the
+ * editor renders) even when the active building is rotated. Snapping in the
+ * building's local frame would otherwise chase the rotated axes and miss
+ * the visible grid lines.
+ */
+export function snapWorldXZToBuildingLocal(worldX, worldZ, buildingPosition, buildingRotationY, step = DEFAULT_GRID_STEP) {
+    if (step <= 0) {
+        const dx = worldX - buildingPosition[0];
+        const dz = worldZ - buildingPosition[2];
+        const cos = Math.cos(buildingRotationY);
+        const sin = Math.sin(buildingRotationY);
+        return {
+            world: [worldX, worldZ],
+            local: [dx * cos - dz * sin, dx * sin + dz * cos],
+        };
+    }
+    const snappedWX = Math.round(worldX / step) * step;
+    const snappedWZ = Math.round(worldZ / step) * step;
+    const dx = snappedWX - buildingPosition[0];
+    const dz = snappedWZ - buildingPosition[2];
+    const cos = Math.cos(buildingRotationY);
+    const sin = Math.sin(buildingRotationY);
+    // The forward (local → world) rotation used in the editor is
+    //   wx = bx + lx*cos + lz*sin
+    //   wz = bz - lx*sin + lz*cos
+    // so the inverse (orthogonal, so transpose) is
+    //   lx =  dx*cos - dz*sin
+    //   lz =  dx*sin + dz*cos
+    return {
+        world: [snappedWX, snappedWZ],
+        local: [dx * cos - dz * sin, dx * sin + dz * cos],
+    };
+}
+// ─── Angle snap ───────────────────────────────────────────────────────
+/**
+ * Snaps a cursor point to the nearest angle multiple of `angleStep` (radians)
+ * measured from `from`, preserving distance. Useful for axis/diagonal-locked
+ * placement and wall draft endpoint locking.
+ *
+ * After the angle snap, the result is grid-snapped if `gridStep` is provided
+ * — keeps endpoints landing on grid intersections.
+ */
+export function snapPointToAngle(from, cursor, angleStep = DEFAULT_ANGLE_STEP, gridStep) {
+    const dx = cursor[0] - from[0];
+    const dz = cursor[1] - from[1];
+    const angle = Math.atan2(dz, dx);
+    const snappedAngle = Math.round(angle / angleStep) * angleStep;
+    const distance = Math.hypot(dx, dz);
+    const projected = [
+        from[0] + Math.cos(snappedAngle) * distance,
+        from[1] + Math.sin(snappedAngle) * distance,
+    ];
+    return gridStep == null ? projected : snapPointToGrid(projected, gridStep);
+}
+/**
+ * Snaps an angle (in radians) to the nearest entry in `snapAngles` (also in
+ * radians). Returns the original angle if no entry is within `toleranceRad`.
+ */
+export function snapAngleToList(angle, snapAngles, toleranceRad = Math.PI / 36) {
+    let best = null;
+    let bestDelta = Number.POSITIVE_INFINITY;
+    for (const target of snapAngles) {
+        // wrap delta to [-π, π]
+        let delta = ((angle - target) % (Math.PI * 2)) + Math.PI * 3;
+        delta = (delta % (Math.PI * 2)) - Math.PI;
+        const abs = Math.abs(delta);
+        if (abs < bestDelta && abs <= toleranceRad) {
+            bestDelta = abs;
+            best = target;
+        }
+    }
+    return best ?? angle;
+}
+export const snapServices = {
+    grid: {
+        snap: snapPointToGrid,
+        snapVec3: snapVec3ToGrid,
+        snapScalar,
+    },
+    angle: {
+        snapTo: snapPointToAngle,
+        snapToList: snapAngleToList,
+    },
+};

package/dist/services/snap.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snap.test.d.ts.map

package/dist/services/snap.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snap.test.d.ts","sourceRoot":"","sources":["../../src/services/snap.test.ts"],"names":[],"mappings":""}

package/dist/services/snap.test.js

@@ -0,0 +1,95 @@
+import { describe, expect, test } from 'bun:test';
+import { DEFAULT_ANGLE_STEP, DEFAULT_GRID_STEP, snapAngleToList, snapPointToAngle, snapPointToGrid, snapScalar, snapServices, snapVec3ToGrid, } from './snap';
+describe('snapScalar', () => {
+    test('rounds to multiples of step', () => {
+        expect(snapScalar(0.27, 0.25)).toBe(0.25);
+        expect(snapScalar(0.13, 0.25)).toBe(0.25);
+        expect(snapScalar(0.12, 0.25)).toBe(0);
+        expect(snapScalar(1.7, 0.25)).toBeCloseTo(1.75);
+    });
+    test('returns input unchanged when step is non-positive', () => {
+        expect(snapScalar(0.42, 0)).toBe(0.42);
+        expect(snapScalar(0.42, -1)).toBe(0.42);
+    });
+    test('default step is 0.25m', () => {
+        expect(snapScalar(0.3)).toBe(0.25);
+        expect(snapScalar(0.4)).toBe(0.5);
+        expect(DEFAULT_GRID_STEP).toBe(0.25);
+    });
+});
+describe('snapPointToGrid', () => {
+    test('snaps both components independently', () => {
+        expect(snapPointToGrid([0.3, 0.6], 0.25)).toEqual([0.25, 0.5]);
+    });
+    test('preserves exact-grid points', () => {
+        expect(snapPointToGrid([1, 2], 0.5)).toEqual([1, 2]);
+    });
+});
+describe('snapVec3ToGrid', () => {
+    test('snaps X and Z, leaves Y untouched', () => {
+        expect(snapVec3ToGrid([0.3, 1.7, 0.6], 0.25)).toEqual([0.25, 1.7, 0.5]);
+    });
+});
+describe('snapPointToAngle', () => {
+    test('snaps to axis (0°) when cursor is near horizontal', () => {
+        const from = [0, 0];
+        const cursor = [1, 0.05]; // near 0°
+        const snapped = snapPointToAngle(from, cursor, Math.PI / 4);
+        expect(snapped[0]).toBeCloseTo(1, 1);
+        expect(snapped[1]).toBeCloseTo(0, 5);
+    });
+    test('snaps to 45° at π/4 step', () => {
+        const from = [0, 0];
+        const cursor = [1, 0.9]; // near 45°
+        const snapped = snapPointToAngle(from, cursor, Math.PI / 4);
+        // distance preserved (≈ √(1² + 0.9²) ≈ 1.345), angle locked to 45°
+        const expectedDist = Math.hypot(1, 0.9);
+        expect(snapped[0]).toBeCloseTo(expectedDist * Math.cos(Math.PI / 4));
+        expect(snapped[1]).toBeCloseTo(expectedDist * Math.sin(Math.PI / 4));
+    });
+    test('default angle step is π/12 (15°)', () => {
+        expect(DEFAULT_ANGLE_STEP).toBeCloseTo(Math.PI / 12);
+    });
+    test('grid-snaps the projected point when gridStep is provided', () => {
+        const from = [0, 0];
+        const cursor = [1.05, 0.02]; // ~horizontal, slightly off grid
+        const snapped = snapPointToAngle(from, cursor, Math.PI / 4, 0.25);
+        // After 0° lock + 0.25m grid, X must be a 0.25 multiple.
+        expect(snapped[0] / 0.25).toBeCloseTo(Math.round(snapped[0] / 0.25));
+    });
+    test('preserves distance from `from`', () => {
+        const from = [2, 3];
+        const cursor = [3, 4];
+        const distance = Math.hypot(1, 1);
+        const snapped = snapPointToAngle(from, cursor, Math.PI / 4);
+        expect(Math.hypot(snapped[0] - 2, snapped[1] - 3)).toBeCloseTo(distance);
+    });
+});
+describe('snapAngleToList', () => {
+    test('snaps to the nearest entry within tolerance', () => {
+        const targets = [0, Math.PI / 2, Math.PI, (3 * Math.PI) / 2];
+        expect(snapAngleToList(0.05, targets, Math.PI / 36)).toBe(0);
+        expect(snapAngleToList(Math.PI / 2 + 0.02, targets, Math.PI / 36)).toBe(Math.PI / 2);
+    });
+    test('returns original angle when no target is within tolerance', () => {
+        const targets = [0, Math.PI / 2];
+        expect(snapAngleToList(0.5, targets, Math.PI / 36)).toBe(0.5);
+    });
+    test('handles wrap-around near ±π', () => {
+        const targets = [Math.PI];
+        expect(snapAngleToList(-Math.PI + 0.01, targets, Math.PI / 36)).toBe(Math.PI);
+    });
+});
+describe('snapServices facade', () => {
+    test('grid.snap matches snapPointToGrid', () => {
+        expect(snapServices.grid.snap([0.3, 0.6], 0.25)).toEqual(snapPointToGrid([0.3, 0.6], 0.25));
+    });
+    test('grid.snapScalar matches snapScalar', () => {
+        expect(snapServices.grid.snapScalar(0.3, 0.25)).toBe(snapScalar(0.3, 0.25));
+    });
+    test('angle.snapTo matches snapPointToAngle', () => {
+        const from = [0, 0];
+        const cursor = [1, 0.9];
+        expect(snapServices.angle.snapTo(from, cursor, Math.PI / 4)).toEqual(snapPointToAngle(from, cursor, Math.PI / 4));
+    });
+});

package/dist/solar-panel-presets.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const SolarPanelPresetKey: z.ZodEnum<{
+    residential: "residential";
+    "residential-large": "residential-large";
+    compact: "compact";
+    frameless: "frameless";
+}>;
+export type SolarPanelPresetKey = z.infer<typeof SolarPanelPresetKey>;
+export type SolarPanelPresetDims = {
+    panelWidth: number;
+    panelHeight: number;
+    frameThickness: number;
+    frameDepth: number;
+};
+export declare const SOLAR_PANEL_PRESETS: Record<SolarPanelPresetKey, SolarPanelPresetDims>;
+export declare const SOLAR_PANEL_PRESET_LABELS: Record<SolarPanelPresetKey, string>;
+//# sourceMappingURL=solar-panel-presets.d.ts.map

package/dist/solar-panel-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solar-panel-presets.d.ts","sourceRoot":"","sources":["../src/solar-panel-presets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,eAAO,MAAM,mBAAmB;;;;;EAK9B,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,mBAAmB,EAAE,oBAAoB,CAyBjF,CAAA;AAED,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAKzE,CAAA"}

package/dist/solar-panel-presets.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+// Vendor-neutral visual presets. Picking one writes the four `panelWidth`,
+// `panelHeight`, `frameThickness`, `frameDepth` fields onto a SolarPanelNode.
+// Manually editing any of those four fields clears the preset back to undefined
+// ("Custom") so the schema's `panelTypePreset` always matches the dims.
+export const SolarPanelPresetKey = z.enum([
+    'residential',
+    'residential-large',
+    'compact',
+    'frameless',
+]);
+export const SOLAR_PANEL_PRESETS = {
+    residential: {
+        panelWidth: 1.0,
+        panelHeight: 1.65,
+        frameThickness: 0.04,
+        frameDepth: 0.04,
+    },
+    'residential-large': {
+        panelWidth: 1.0,
+        panelHeight: 2.0,
+        frameThickness: 0.04,
+        frameDepth: 0.04,
+    },
+    compact: {
+        panelWidth: 0.83,
+        panelHeight: 1.0,
+        frameThickness: 0.03,
+        frameDepth: 0.035,
+    },
+    frameless: {
+        panelWidth: 1.0,
+        panelHeight: 1.65,
+        frameThickness: 0.005,
+        frameDepth: 0.025,
+    },
+};
+export const SOLAR_PANEL_PRESET_LABELS = {
+    residential: 'Residential',
+    'residential-large': 'Residential Large',
+    compact: 'Compact',
+    frameless: 'Frameless',
+};

package/dist/store/actions/node-actions.d.ts

@@ -1,12 +1,24 @@
 import { type AnyNode, type AnyNodeId } from '../../schema';
 import type { SceneState } from '../use-scene';
-export declare const createNodesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, ops: {
+type NodeCreateOp = {
     node: AnyNode;
     parentId?: AnyNodeId;
-}[]) => void;
+};
+type NodeUpdateOp = {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+};
+type NodeDeleteOp = AnyNodeId;
+export declare const createNodesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, ops: NodeCreateOp[]) => void;
+export declare const applyNodeChangesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, changes: {
+    create?: NodeCreateOp[];
+    update?: NodeUpdateOp[];
+    delete?: NodeDeleteOp[];
+}) => void;
 export declare const updateNodesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, updates: {
     id: AnyNodeId;
     data: Partial<AnyNode>;
 }[]) => void;
 export declare const deleteNodesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, ids: AnyNodeId[]) => void;
+export {};
 //# sourceMappingURL=node-actions.d.ts.map

package/dist/store/actions/node-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAIf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AA6N9C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,EAAE,SA8C/C,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SA+DrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAsGjB,CAAA"}
+{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAKf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,KAAK,YAAY,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAC7D,KAAK,YAAY,GAAG,SAAS,CAAA;AAqrB7B,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,YAAY,EAAE,SAkDpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,SAoIvF,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SA2ErD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAsGjB,CAAA"}