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

package/dist/systems/window/window-animation-system.js

@@ -1,12 +1,7 @@
 import { emitter, sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
-import { AWNING_WINDOW_SASH_NAME, CASEMENT_WINDOW_SASH_NAME, DOUBLE_HUNG_BOTTOM_SASH_NAME, DOUBLE_HUNG_TOP_SASH_NAME, FRENCH_CASEMENT_LEFT_SASH_NAME, FRENCH_CASEMENT_RIGHT_SASH_NAME, HOPPER_WINDOW_SASH_NAME, LOUVERED_WINDOW_SLATS_NAME, SINGLE_HUNG_ACTIVE_SASH_NAME, SLIDING_WINDOW_ACTIVE_PANEL_NAME, } from './window-system';
+import { AWNING_WINDOW_SASH_NAME, CASEMENT_WINDOW_SASH_NAME, DOUBLE_HUNG_BOTTOM_SASH_NAME, DOUBLE_HUNG_TOP_SASH_NAME, FRENCH_CASEMENT_LEFT_SASH_NAME, FRENCH_CASEMENT_RIGHT_SASH_NAME, HOPPER_WINDOW_SASH_NAME, LOUVERED_WINDOW_SLATS_NAME, pendingWindowAnimationRebuilds, SINGLE_HUNG_ACTIVE_SASH_NAME, SLIDING_WINDOW_ACTIVE_PANEL_NAME, } from './window-system';
 const easeWindowAnimation = (value) => value * value * (3 - 2 * value);
-function markWindowDirty(windowId) {
-    const scene = useScene.getState();
-    const node = scene.nodes[windowId];
-    scene.dirtyNodes.add(windowId);
-}
 /**
  * Pose a window's moving parts (sash/panel/slats) at `value` (0 = closed,
  * 1 = open) by mutating the named child groups under `mesh`. Returns true when
@@ -123,18 +118,24 @@ export const WindowAnimationSystem = () => {
             const value = animation.from + (animation.to - animation.from) * easeWindowAnimation(progress);
             interactive.setWindowOpenState(typedWindowId, { [animation.field]: value });
             const appliedDirectly = applyDirectWindowAnimation(typedWindowId, value);
+            // A dirty mark is one-shot work, not a needs-frame signal — per-tick
+            // marks kept the scene from ever settling. Types without a direct pose
+            // path get a transient rebuild request instead.
             if (!appliedDirectly)
-                markWindowDirty(typedWindowId);
+                pendingWindowAnimationRebuilds.add(typedWindowId);
             if (progress < 1)
                 continue;
             interactive.cancelWindowAnimation(typedWindowId);
             if (animation.persist) {
                 scene.updateNode(typedWindowId, { [animation.field]: animation.to });
                 interactive.removeWindowOpenState(typedWindowId);
-                markWindowDirty(typedWindowId);
+                // One-shot: the rebuild re-derives the pose from the persisted node.
+                scene.markDirty(typedWindowId);
             }
             else {
                 interactive.setWindowOpenState(typedWindowId, { [animation.field]: animation.to });
+                if (!appliedDirectly)
+                    scene.markDirty(typedWindowId);
             }
             emitter.emit('window:animation-completed', {
                 windowId: typedWindowId,

package/dist/systems/window/window-system.d.ts

@@ -10,6 +10,7 @@ export declare const DOUBLE_HUNG_BOTTOM_SASH_NAME = "double-hung-bottom-sash";
 export declare const LOUVERED_WINDOW_SLATS_NAME = "louvered-window-slats";
 export declare const AWNING_WINDOW_SASH_NAME = "awning-window-sash";
 export declare const HOPPER_WINDOW_SASH_NAME = "hopper-window-sash";
+export declare const pendingWindowAnimationRebuilds: Set<`building_${string}` | `level_${string}` | `elevator_${string}` | `item_${string}` | `block_${string}` | `ceiling_${string}` | `column_${string}` | `wall_${string}` | `roof_${string}` | `slab_${string}` | `fence_${string}` | `construction-dimension_${string}` | `structural-grid_${string}` | `zone_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}` | `site_${string}` | `leanto_${string}` | `door_${string}` | `window_${string}` | `cabinet-module_${string}` | `cabinet_${string}` | `rseg_${string}` | `sseg_${string}` | `bvent_${string}` | `rvent_${string}` | `tvent_${string}` | `cupola_${string}` | `eyebrow-vent_${string}` | `gutter_${string}` | `chimney_${string}` | `solarpanel_${string}` | `skylight_${string}` | `dormer_${string}` | `downspout_${string}`>;
 export declare const WindowSystem: () => null;
 /**
  * Build a fresh window mesh for preview/ghost rendering.

package/dist/systems/window/window-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAYL,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAwB9B,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,8BAA8B,8BAA8B,CAAA;AACzE,eAAO,MAAM,+BAA+B,+BAA+B,CAAA;AAC3E,eAAO,MAAM,gCAAgC,gCAAgC,CAAA;AAC7E,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAM3D,eAAO,MAAM,YAAY,YA4GxB,CAAA;AA28GD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,IAAI,CAInE"}
+{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAYL,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAyB9B,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,8BAA8B,8BAA8B,CAAA;AACzE,eAAO,MAAM,+BAA+B,+BAA+B,CAAA;AAC3E,eAAO,MAAM,gCAAgC,gCAAgC,CAAA;AAC7E,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAS3D,eAAO,MAAM,8BAA8B,kkCAAuB,CAAA;AAElE,eAAO,MAAM,YAAY,YAoHxB,CAAA;AA28GD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC,IAAI,CAInE"}

package/dist/systems/window/window-system.js

@@ -4,6 +4,7 @@ import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
 import { applyWorldScaleBoxUVs } from '../../lib/box-uv';
 import { createSurfaceRoleMaterial, glassMaterial as defaultGlassMaterial, baseMaterial as getBaseMaterial, resolveMaterialRef, } from '../../lib/materials';
+import { timeSpan } from '../../lib/perf-tracks';
 import useViewer from '../../store/use-viewer';
 import { getOpeningCutoutProxyDepth } from '../wall/opening-cutout-geometry';
 // Invisible material for root mesh — used as selection hitbox only
@@ -30,6 +31,10 @@ export const HOPPER_WINDOW_SASH_NAME = 'hopper-window-sash';
 const MAX_WINDOW_REBUILDS_PER_FRAME = 16;
 const WINDOW_PROGRESSIVE_DIRTY_THRESHOLD = MAX_WINDOW_REBUILDS_PER_FRAME;
 const WINDOW_PROGRESSIVE_TIME_BUDGET_MS = 8;
+// Transient rebuild requests from WindowAnimationSystem for windows whose type
+// has no direct pose path: drained every frame. Deliberately not dirtyNodes —
+// a running animation must not keep the dirty set from reaching zero.
+export const pendingWindowAnimationRebuilds = new Set();
 export const WindowSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
@@ -74,7 +79,7 @@ export const WindowSystem = () => {
         }
     }, [sceneMaterials]);
     useFrame(() => {
-        if (dirtyNodes.size === 0)
+        if (dirtyNodes.size === 0 && pendingWindowAnimationRebuilds.size === 0)
             return;
         baseMaterial = textures
             ? getBaseMaterial(shading)
@@ -94,6 +99,13 @@ export const WindowSystem = () => {
                 return;
             dirtyWindowIds.push(id);
         });
+        if (pendingWindowAnimationRebuilds.size > 0) {
+            for (const id of pendingWindowAnimationRebuilds) {
+                if (nodes[id]?.type === 'window' && !dirtyWindowIds.includes(id))
+                    dirtyWindowIds.push(id);
+            }
+            pendingWindowAnimationRebuilds.clear();
+        }
         const useProgressiveWindowRebuilds = dirtyWindowIds.length > WINDOW_PROGRESSIVE_DIRTY_THRESHOLD;
         const frameStartedAt = performance.now();
         let rebuiltWindowsThisFrame = 0;
@@ -116,7 +128,9 @@ export const WindowSystem = () => {
             // Merge any live override (width / height / position) so the mesh
             // rebuild reflects the in-flight drag without zustand churn.
             const effectiveNode = getEffectiveNode(node);
-            updateWindowMesh(effectiveNode, mesh);
+            timeSpan('window', () => updateWindowMesh(effectiveNode, mesh), {
+                properties: [['node', id]],
+            });
             clearDirty(id);
             rebuiltWindowsThisFrame += 1;
             // Rebuild the parent wall so its cutout reflects the updated window geometry

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/viewer",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0",
   "description": "3D viewer component for Pascal building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,6 +10,16 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./capture": {
+      "types": "./dist/capture/index.d.ts",
+      "import": "./dist/capture/index.js",
+      "default": "./dist/capture/index.js"
+    },
+    "./capture/preview": {
+      "types": "./dist/capture/preview.d.ts",
+      "import": "./dist/capture/preview.js",
+      "default": "./dist/capture/preview.js"
     }
   },
   "files": [
@@ -23,11 +33,12 @@
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.0-beta.5",
+    "@pascal-app/core": "^1.0.0",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
-    "three": "^0.185"
+    "react-dom": "^18 || ^19",
+    "three": "^0.186"
   },
   "dependencies": {
     "three-bvh-csg": "^0.0.18",
@@ -35,10 +46,12 @@
     "zustand": "^5"
   },
   "devDependencies": {
-    "@pascal-app/core": "^1.0.0-beta.5",
+    "@pascal-app/core": "^1.0.0",
     "@pascal/typescript-config": "*",
+    "@react-three/test-renderer": "^9.1.0",
     "@types/node": "^22",
     "@types/react": "^19.2.2",
+    "@types/react-dom": "19.2.2",
     "@types/three": "^0.184.0",
     "typescript": "6.0.3"
   },

package/dist/lib/polygon-union.d.ts

@@ -1,4 +0,0 @@
-export type Point2D = [number, number];
-export declare function unionPolygons(polygons: Point2D[][]): Point2D[][];
-export declare function subtractPolygonsFromPolygon(subject: Point2D[], cutters: Point2D[][]): Point2D[][];
-//# sourceMappingURL=polygon-union.d.ts.map

package/dist/lib/polygon-union.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"polygon-union.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-union.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAwStC,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAShE;AA4CD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAkBjG"}

package/dist/lib/polygon-union.js

@@ -1,289 +0,0 @@
-const EPSILON = 1e-7;
-const KEY_SCALE = 1e6;
-function pointsEqual(a, b, tolerance = EPSILON) {
-    return Math.hypot(a[0] - b[0], a[1] - b[1]) <= tolerance;
-}
-function pointKey(point) {
-    return `${Math.round(point[0] * KEY_SCALE)}:${Math.round(point[1] * KEY_SCALE)}`;
-}
-function interpolate(a, b, t) {
-    return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
-}
-function cross(ax, ay, bx, by) {
-    return ax * by - ay * bx;
-}
-function polygonArea(points) {
-    let area = 0;
-    for (let i = 0; i < points.length; i++) {
-        const current = points[i];
-        const next = points[(i + 1) % points.length];
-        area += current[0] * next[1] - next[0] * current[1];
-    }
-    return area / 2;
-}
-function pointOnSegment(point, start, end) {
-    const dx = end[0] - start[0];
-    const dz = end[1] - start[1];
-    const crossValue = cross(point[0] - start[0], point[1] - start[1], dx, dz);
-    if (Math.abs(crossValue) > EPSILON)
-        return false;
-    const dot = (point[0] - start[0]) * (point[0] - end[0]) + (point[1] - start[1]) * (point[1] - end[1]);
-    return dot <= EPSILON;
-}
-function pointInPolygonOrOnBoundary(point, polygon) {
-    if (polygon.some((start, index) => pointOnSegment(point, start, polygon[(index + 1) % polygon.length]))) {
-        return true;
-    }
-    return pointInPolygon(point, polygon);
-}
-function pointInPolygon(point, polygon) {
-    let inside = false;
-    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-        const pi = polygon[i];
-        const pj = polygon[j];
-        if (pointOnSegment(point, pj, pi))
-            return false;
-        const intersects = pi[1] > point[1] !== pj[1] > point[1] &&
-            point[0] < ((pj[0] - pi[0]) * (point[1] - pi[1])) / (pj[1] - pi[1]) + pi[0];
-        if (intersects)
-            inside = !inside;
-    }
-    return inside;
-}
-function normalizeRing(ring) {
-    const normalized = [];
-    for (const [x, z] of ring) {
-        if (!Number.isFinite(x) || !Number.isFinite(z))
-            continue;
-        const point = [x, z];
-        const previous = normalized[normalized.length - 1];
-        if (!previous || !pointsEqual(previous, point)) {
-            normalized.push(point);
-        }
-    }
-    const first = normalized[0];
-    const last = normalized[normalized.length - 1];
-    if (first && last && pointsEqual(first, last)) {
-        normalized.pop();
-    }
-    if (normalized.length < 3 || Math.abs(polygonArea(normalized)) <= EPSILON)
-        return [];
-    return polygonArea(normalized) < 0 ? [...normalized].reverse() : normalized;
-}
-function addSplit(edge, t) {
-    if (t < -EPSILON || t > 1 + EPSILON)
-        return;
-    const clamped = Math.max(0, Math.min(1, t));
-    if (edge.splits.some((split) => Math.abs(split - clamped) <= EPSILON))
-        return;
-    edge.splits.push(clamped);
-}
-function parameterOnEdge(point, edge) {
-    const dx = edge.end[0] - edge.start[0];
-    const dz = edge.end[1] - edge.start[1];
-    const lengthSquared = dx * dx + dz * dz;
-    if (lengthSquared <= EPSILON)
-        return 0;
-    return ((point[0] - edge.start[0]) * dx + (point[1] - edge.start[1]) * dz) / lengthSquared;
-}
-function addIntersectionSplits(left, right) {
-    const rx = left.end[0] - left.start[0];
-    const rz = left.end[1] - left.start[1];
-    const sx = right.end[0] - right.start[0];
-    const sz = right.end[1] - right.start[1];
-    const qpx = right.start[0] - left.start[0];
-    const qpz = right.start[1] - left.start[1];
-    const denominator = cross(rx, rz, sx, sz);
-    const numerator = cross(qpx, qpz, rx, rz);
-    if (Math.abs(denominator) <= EPSILON) {
-        if (Math.abs(numerator) > EPSILON)
-            return;
-        for (const point of [left.start, left.end, right.start, right.end]) {
-            if (pointOnSegment(point, left.start, left.end) &&
-                pointOnSegment(point, right.start, right.end)) {
-                addSplit(left, parameterOnEdge(point, left));
-                addSplit(right, parameterOnEdge(point, right));
-            }
-        }
-        return;
-    }
-    const t = cross(qpx, qpz, sx, sz) / denominator;
-    const u = cross(qpx, qpz, rx, rz) / denominator;
-    if (t < -EPSILON || t > 1 + EPSILON || u < -EPSILON || u > 1 + EPSILON)
-        return;
-    addSplit(left, t);
-    addSplit(right, u);
-}
-function buildEdges(polygons) {
-    const edges = [];
-    polygons.forEach((polygon, polygonIndex) => {
-        for (let i = 0; i < polygon.length; i++) {
-            edges.push({
-                start: polygon[i],
-                end: polygon[(i + 1) % polygon.length],
-                polygonIndex,
-                splits: [0, 1],
-            });
-        }
-    });
-    for (let i = 0; i < edges.length; i++) {
-        for (let j = i + 1; j < edges.length; j++) {
-            const left = edges[i];
-            const right = edges[j];
-            if (left.polygonIndex === right.polygonIndex)
-                continue;
-            addIntersectionSplits(left, right);
-        }
-    }
-    return edges;
-}
-function buildBoundarySegments(edges, polygons) {
-    const segments = [];
-    for (const edge of edges) {
-        const splits = [...edge.splits].sort((a, b) => a - b);
-        for (let i = 0; i < splits.length - 1; i++) {
-            const startT = splits[i];
-            const endT = splits[i + 1];
-            if (endT - startT <= EPSILON)
-                continue;
-            const start = interpolate(edge.start, edge.end, startT);
-            const end = interpolate(edge.start, edge.end, endT);
-            const mid = interpolate(edge.start, edge.end, (startT + endT) / 2);
-            const insideAnother = polygons.some((polygon, index) => index !== edge.polygonIndex && pointInPolygon(mid, polygon));
-            if (!insideAnother) {
-                segments.push({ start, end, used: false });
-            }
-        }
-    }
-    return removeDuplicateInteriorSegments(segments);
-}
-function segmentKey(segment) {
-    const start = pointKey(segment.start);
-    const end = pointKey(segment.end);
-    return start < end ? `${start}|${end}` : `${end}|${start}`;
-}
-function removeDuplicateInteriorSegments(segments) {
-    const groups = new Map();
-    for (const segment of segments) {
-        const key = segmentKey(segment);
-        const group = groups.get(key);
-        if (group) {
-            group.push(segment);
-        }
-        else {
-            groups.set(key, [segment]);
-        }
-    }
-    const result = [];
-    for (const group of groups.values()) {
-        if (group.length === 1) {
-            result.push(group[0]);
-            continue;
-        }
-        const firstStart = pointKey(group[0].start);
-        const firstEnd = pointKey(group[0].end);
-        const hasOppositeDirection = group.some((segment) => pointKey(segment.start) === firstEnd && pointKey(segment.end) === firstStart);
-        if (!hasOppositeDirection) {
-            result.push(group[0]);
-        }
-    }
-    return result;
-}
-function assembleRings(segments) {
-    const byStart = new Map();
-    for (const segment of segments) {
-        const key = pointKey(segment.start);
-        const group = byStart.get(key);
-        if (group) {
-            group.push(segment);
-        }
-        else {
-            byStart.set(key, [segment]);
-        }
-    }
-    const rings = [];
-    for (const firstSegment of segments) {
-        if (firstSegment.used)
-            continue;
-        firstSegment.used = true;
-        const ring = [firstSegment.start, firstSegment.end];
-        const startKey = pointKey(firstSegment.start);
-        let currentKey = pointKey(firstSegment.end);
-        while (currentKey !== startKey) {
-            const next = byStart.get(currentKey)?.find((segment) => !segment.used);
-            if (!next)
-                break;
-            next.used = true;
-            ring.push(next.end);
-            currentKey = pointKey(next.end);
-        }
-        if (currentKey !== startKey)
-            continue;
-        const last = ring[ring.length - 1];
-        if (last && pointsEqual(ring[0], last)) {
-            ring.pop();
-        }
-        const normalized = normalizeRing(ring);
-        if (normalized.length >= 3) {
-            rings.push(normalized);
-        }
-    }
-    return rings;
-}
-export function unionPolygons(polygons) {
-    const validPolygons = polygons.map(normalizeRing).filter((polygon) => polygon.length >= 3);
-    if (validPolygons.length <= 1)
-        return validPolygons;
-    const edges = buildEdges(validPolygons);
-    const segments = buildBoundarySegments(edges, validPolygons);
-    const rings = assembleRings(segments);
-    return rings.length > 0 ? rings : validPolygons;
-}
-function buildDifferenceBoundarySegments(edges, polygons) {
-    const subject = polygons[0];
-    const cutters = polygons.slice(1);
-    if (!subject)
-        return [];
-    const segments = [];
-    for (const edge of edges) {
-        const splits = [...edge.splits].sort((a, b) => a - b);
-        for (let i = 0; i < splits.length - 1; i++) {
-            const startT = splits[i];
-            const endT = splits[i + 1];
-            if (endT - startT <= EPSILON)
-                continue;
-            const start = interpolate(edge.start, edge.end, startT);
-            const end = interpolate(edge.start, edge.end, endT);
-            const mid = interpolate(edge.start, edge.end, (startT + endT) / 2);
-            if (edge.polygonIndex === 0) {
-                const insideCutter = cutters.some((cutter) => pointInPolygonOrOnBoundary(mid, cutter));
-                if (!insideCutter) {
-                    segments.push({ start, end, used: false });
-                }
-                continue;
-            }
-            const insideSubject = pointInPolygon(mid, subject);
-            const insideAnotherCutter = cutters.some((cutter, cutterIndex) => cutterIndex !== edge.polygonIndex - 1 && pointInPolygonOrOnBoundary(mid, cutter));
-            if (insideSubject && !insideAnotherCutter) {
-                segments.push({ start: end, end: start, used: false });
-            }
-        }
-    }
-    return removeDuplicateInteriorSegments(segments);
-}
-export function subtractPolygonsFromPolygon(subject, cutters) {
-    const validSubject = normalizeRing(subject);
-    if (validSubject.length < 3)
-        return [];
-    const validCutters = cutters.map(normalizeRing).filter((polygon) => polygon.length >= 3);
-    if (validCutters.length === 0)
-        return [validSubject];
-    const polygons = [validSubject, ...validCutters];
-    const edges = buildEdges(polygons);
-    const segments = buildDifferenceBoundarySegments(edges, polygons);
-    const rings = assembleRings(segments);
-    if (rings.length > 0)
-        return rings;
-    const fullyCovered = validSubject.every((point) => validCutters.some((cutter) => pointInPolygonOrOnBoundary(point, cutter)));
-    return fullyCovered ? [] : [validSubject];
-}