kritzel-stencil 0.1.74 → 0.1.76

package/dist/cjs/{workspace.migrations-Dyt35LBC.js → workspace.migrations-DkmVO6dE.js}

@@ -22386,6 +22386,7 @@ class KritzelSelectionTool extends KritzelBaseTool {
  * IndexedDB sync provider for local persistence
  */
 class IndexedDBSyncProvider {
+    type = 'local';
     provider;
     isConnected = false;
     constructor(docName, doc, options) {
@@ -22407,6 +22408,10 @@ class IndexedDBSyncProvider {
         // IndexedDB doesn't need explicit disconnect
         this.isConnected = false;
     }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
     destroy() {
         if (this.provider) {
             this.provider.destroy();
@@ -25602,16 +25607,22 @@ class KritzelAnchorManager {
         if (!KritzelClassHelper.isInstanceOf(selectedObject, 'KritzelLine'))
             return null;
         const line = selectedObject;
-        const startAnchorViz = this.computeAnchorVisualization(line, 'start');
-        const endAnchorViz = this.computeAnchorVisualization(line, 'end');
+        const startAnchorVizRaw = this.computeAnchorVisualization(line, 'start');
+        const endAnchorVizRaw = this.computeAnchorVisualization(line, 'end');
+        const startAnchorViz = this.isFiniteAnchorVisualization(startAnchorVizRaw) ? startAnchorVizRaw : null;
+        const endAnchorViz = this.isFiniteAnchorVisualization(endAnchorVizRaw) ? endAnchorVizRaw : null;
         if (!startAnchorViz && !endAnchorViz)
             return null;
-        const scale = this._core.store.state.scale;
-        const lineStrokeWidth = line.strokeWidth / line.scale;
+        const scale = this.getSafeScale(this._core.store.state.scale);
+        const lineScale = this.getSafeScale(line.scale);
+        const lineStrokeWidth = line.strokeWidth / lineScale;
         const indicatorStrokeWidth = `${2 / scale}`;
         const dashLength = Math.max(lineStrokeWidth * 2, 4 / scale);
         const dashArray = `${dashLength} ${dashLength}`;
         const indicatorRadius = 8 / scale;
+        if (!this.areFiniteNumbers(lineStrokeWidth, dashLength, indicatorRadius)) {
+            return null;
+        }
         return {
             lineStrokeWidth,
             indicatorStrokeWidth,
@@ -25633,31 +25644,39 @@ class KritzelAnchorManager {
         const snapCandidate = this.getSnapCandidate();
         if (!snapCandidate)
             return null;
-        const scale = this._core.store.state.scale;
+        if (!this.areFiniteNumbers(snapCandidate.centerX, snapCandidate.centerY, snapCandidate.lineEndpointX, snapCandidate.lineEndpointY)) {
+            return null;
+        }
+        const scale = this.getSafeScale(this._core.store.state.scale);
         const indicatorRadius = 8 / scale;
         const indicatorStrokeWidth = `${2 / scale}`;
-        const lineStrokeWidth = snapCandidate.lineStrokeWidth
-            ? `${snapCandidate.lineStrokeWidth}`
-            : `${4 / scale}`;
-        const lineStrokeWidthNum = snapCandidate.lineStrokeWidth || (4 / scale);
+        const lineStrokeWidthNum = this.areFiniteNumbers(snapCandidate.lineStrokeWidth) && snapCandidate.lineStrokeWidth > 0
+            ? snapCandidate.lineStrokeWidth
+            : (4 / scale);
+        const lineStrokeWidth = `${lineStrokeWidthNum}`;
         const dashLength = Math.max(lineStrokeWidthNum * 2, 4 / scale);
         const dashArray = `${dashLength} ${dashLength}`;
         const lineStroke = snapCandidate.lineStroke || '#000000';
-        let solidLineEndX = snapCandidate.edgeX;
-        let solidLineEndY = snapCandidate.edgeY;
+        let edgeX = this.areFiniteNumbers(snapCandidate.edgeX) ? snapCandidate.edgeX : undefined;
+        let edgeY = this.areFiniteNumbers(snapCandidate.edgeY) ? snapCandidate.edgeY : undefined;
+        let solidLineEndX = edgeX;
+        let solidLineEndY = edgeY;
         let arrowPoints;
-        if (snapCandidate.arrowOffset && snapCandidate.edgeX !== undefined && snapCandidate.edgeY !== undefined) {
-            const dx = snapCandidate.lineEndpointX - snapCandidate.edgeX;
-            const dy = snapCandidate.lineEndpointY - snapCandidate.edgeY;
+        const arrowOffset = this.areFiniteNumbers(snapCandidate.arrowOffset) && snapCandidate.arrowOffset > 0
+            ? snapCandidate.arrowOffset
+            : undefined;
+        if (arrowOffset !== undefined && edgeX !== undefined && edgeY !== undefined) {
+            const dx = snapCandidate.lineEndpointX - edgeX;
+            const dy = snapCandidate.lineEndpointY - edgeY;
             const length = Math.sqrt(dx * dx + dy * dy);
-            if (length > snapCandidate.arrowOffset) {
-                solidLineEndX = snapCandidate.edgeX + (dx / length) * snapCandidate.arrowOffset;
-                solidLineEndY = snapCandidate.edgeY + (dy / length) * snapCandidate.arrowOffset;
+            if (length > arrowOffset) {
+                solidLineEndX = edgeX + (dx / length) * arrowOffset;
+                solidLineEndY = edgeY + (dy / length) * arrowOffset;
             }
             // Calculate arrow head points
             // Direction from line endpoint to edge (arrow direction)
-            const arrowDx = snapCandidate.edgeX - snapCandidate.lineEndpointX;
-            const arrowDy = snapCandidate.edgeY - snapCandidate.lineEndpointY;
+            const arrowDx = edgeX - snapCandidate.lineEndpointX;
+            const arrowDy = edgeY - snapCandidate.lineEndpointY;
             const arrowLengthTotal = Math.sqrt(arrowDx * arrowDx + arrowDy * arrowDy);
             if (arrowLengthTotal > 0) {
                 const ux = arrowDx / arrowLengthTotal;
@@ -25666,11 +25685,11 @@ class KritzelAnchorManager {
                 const px = -uy;
                 const py = ux;
                 // Arrow dimensions
-                const arrowLength = snapCandidate.arrowOffset;
+                const arrowLength = arrowOffset;
                 const arrowWidth = arrowLength; // 1:1 ratio
                 // Arrow tip at edge
-                const tipX = snapCandidate.edgeX;
-                const tipY = snapCandidate.edgeY;
+                const tipX = edgeX;
+                const tipY = edgeY;
                 // Arrow base
                 const baseX = tipX - ux * arrowLength;
                 const baseY = tipY - uy * arrowLength;
@@ -25679,9 +25698,31 @@ class KritzelAnchorManager {
                 const leftY = baseY + py * arrowWidth / 2;
                 const rightX = baseX - px * arrowWidth / 2;
                 const rightY = baseY - py * arrowWidth / 2;
-                arrowPoints = `${tipX},${tipY} ${leftX},${leftY} ${rightX},${rightY}`;
+                if (this.areFiniteNumbers(tipX, tipY, leftX, leftY, rightX, rightY)) {
+                    arrowPoints = `${tipX},${tipY} ${leftX},${leftY} ${rightX},${rightY}`;
+                }
             }
         }
+        if (!this.areFiniteNumbers(indicatorRadius, lineStrokeWidthNum, dashLength)) {
+            return null;
+        }
+        const snapLinePath = (() => {
+            if (snapCandidate.controlX !== undefined &&
+                snapCandidate.controlY !== undefined &&
+                snapCandidate.t !== undefined &&
+                this.areFiniteNumbers(snapCandidate.controlX, snapCandidate.controlY, snapCandidate.t)) {
+                const startT = snapCandidate.endpoint === 'start' ? 1 - snapCandidate.t : snapCandidate.t;
+                // Ensure meaningful range
+                if (startT >= 1)
+                    return undefined;
+                const segment = this.extractQuadraticSegment({ x: snapCandidate.lineEndpointX, y: snapCandidate.lineEndpointY }, { x: snapCandidate.controlX, y: snapCandidate.controlY }, { x: snapCandidate.centerX, y: snapCandidate.centerY }, startT, 1);
+                if (!this.areFiniteNumbers(segment.start.x, segment.start.y, segment.control.x, segment.control.y, segment.end.x, segment.end.y)) {
+                    return undefined;
+                }
+                return `M ${segment.start.x} ${segment.start.y} Q ${segment.control.x} ${segment.control.y} ${segment.end.x} ${segment.end.y}`;
+            }
+            return undefined;
+        })();
         return {
             indicatorRadius,
             indicatorStrokeWidth,
@@ -25692,27 +25733,15 @@ class KritzelAnchorManager {
             centerY: snapCandidate.centerY,
             lineEndpointX: snapCandidate.lineEndpointX,
             lineEndpointY: snapCandidate.lineEndpointY,
-            edgeX: snapCandidate.edgeX,
-            edgeY: snapCandidate.edgeY,
-            arrowOffset: snapCandidate.arrowOffset,
+            edgeX,
+            edgeY,
+            arrowOffset,
             arrowStyle: snapCandidate.arrowStyle,
             arrowFill: snapCandidate.arrowFill,
             solidLineEndX,
             solidLineEndY,
             arrowPoints,
-            snapLinePath: (() => {
-                if (snapCandidate.controlX !== undefined &&
-                    snapCandidate.controlY !== undefined &&
-                    snapCandidate.t !== undefined) {
-                    const startT = snapCandidate.endpoint === 'start' ? 1 - snapCandidate.t : snapCandidate.t;
-                    // Ensure meaningful range
-                    if (startT >= 1)
-                        return undefined;
-                    const segment = this.extractQuadraticSegment({ x: snapCandidate.lineEndpointX, y: snapCandidate.lineEndpointY }, { x: snapCandidate.controlX, y: snapCandidate.controlY }, { x: snapCandidate.centerX, y: snapCandidate.centerY }, startT, 1);
-                    return `M ${segment.start.x} ${segment.start.y} Q ${segment.control.x} ${segment.control.y} ${segment.end.x} ${segment.end.y}`;
-                }
-                return undefined;
-            })(),
+            snapLinePath,
         };
     }
     // ============================================
@@ -25890,12 +25919,19 @@ class KritzelAnchorManager {
             return null;
         const centerX = targetObject.centerX;
         const centerY = targetObject.centerY;
+        if (!this.areFiniteNumbers(clipInfo.worldX, clipInfo.worldY, centerX, centerY)) {
+            return null;
+        }
+        const pathD = this.buildAnchorPath(line, endpoint, clipInfo, targetObject) ?? undefined;
+        if (pathD && !this.isFinitePathData(pathD)) {
+            return null;
+        }
         return {
             edgeX: clipInfo.worldX,
             edgeY: clipInfo.worldY,
             centerX,
             centerY,
-            pathD: this.buildAnchorPath(line, endpoint, clipInfo, targetObject) ?? undefined,
+            pathD,
         };
     }
     /**
@@ -26608,9 +26644,10 @@ class KritzelAnchorManager {
         const sin = Math.sin(line.rotation);
         const rotatedX = (px - cx) * cos - (py - cy) * sin + cx;
         const rotatedY = (px - cx) * sin + (py - cy) * cos + cy;
+        const safeLineScale = this.getSafeScale(line.scale);
         return {
-            x: rotatedX / line.scale + line.translateX,
-            y: rotatedY / line.scale + line.translateY,
+            x: rotatedX / safeLineScale + line.translateX,
+            y: rotatedY / safeLineScale + line.translateY,
         };
     }
     /**
@@ -26624,8 +26661,9 @@ class KritzelAnchorManager {
      * @returns Object with x and y coordinates in the line's local SVG space.
      */
     lineWorldToLocal(line, worldX, worldY) {
-        const dx = (worldX - line.translateX) * line.scale;
-        const dy = (worldY - line.translateY) * line.scale;
+        const safeLineScale = this.getSafeScale(line.scale);
+        const dx = (worldX - line.translateX) * safeLineScale;
+        const dy = (worldY - line.translateY) * safeLineScale;
         const cx = line.totalWidth / 2;
         const cy = line.totalHeight / 2;
         const cos = Math.cos(-line.rotation);
@@ -26637,6 +26675,30 @@ class KritzelAnchorManager {
             y: rotatedY + line.y,
         };
     }
+    getSafeScale(scale) {
+        if (Number.isFinite(scale) && Math.abs(scale) > 1e-6) {
+            return scale;
+        }
+        return 1;
+    }
+    areFiniteNumbers(...values) {
+        return values.every(value => value !== undefined && Number.isFinite(value));
+    }
+    isFiniteAnchorVisualization(visualization) {
+        if (!visualization) {
+            return false;
+        }
+        if (!this.areFiniteNumbers(visualization.edgeX, visualization.edgeY, visualization.centerX, visualization.centerY)) {
+            return false;
+        }
+        if (visualization.pathD && !this.isFinitePathData(visualization.pathD)) {
+            return false;
+        }
+        return true;
+    }
+    isFinitePathData(pathD) {
+        return !pathD.includes('Infinity') && !pathD.includes('NaN');
+    }
     /**
      * Checks if an object can be used as an anchor target.
      * Excludes selection-related objects (SelectionBox, SelectionGroup) and

package/dist/collection/classes/core/viewport.class.js

@@ -21,6 +21,14 @@ export class KritzelViewport {
     startX = 0;
     /** Starting Y position for pan/zoom gestures */
     startY = 0;
+    /** Minimum movement distance (in screen pixels) before broadcasting touch cursor position */
+    static TOUCH_CURSOR_BROADCAST_THRESHOLD = 5;
+    /** Screen X position where the current touch interaction started */
+    _touchStartScreenX = 0;
+    /** Screen Y position where the current touch interaction started */
+    _touchStartScreenY = 0;
+    /** Whether the touch movement threshold has been exceeded for cursor broadcasting */
+    _touchCursorBroadcastActive = false;
     /**
      * Creates a new KritzelViewport instance and initializes viewport state.
      * Sets up debounced handlers for viewport updates and scaling end events.
@@ -148,7 +156,13 @@ export class KritzelViewport {
         }
         if (event.pointerType === 'touch' || event.pointerType === 'pen') {
             const activePointers = Array.from(this._core.store.state.pointers.values());
+            if (activePointers.length === 1) {
+                this._touchStartScreenX = event.clientX;
+                this._touchStartScreenY = event.clientY;
+                this._touchCursorBroadcastActive = false;
+            }
             if (activePointers.length === 2) {
+                this._core.store.state.objects?.clearCursorPosition();
                 const currentPath = this._core.store.currentPath;
                 if (currentPath) {
                     this._core.store.state.objects.remove(obj => obj.id === currentPath.id);
@@ -209,10 +223,24 @@ export class KritzelViewport {
             const hostRect = this._core.store.state.host.getBoundingClientRect();
             const xRelativeToHost = event.clientX - hostRect.left;
             const yRelativeToHost = event.clientY - hostRect.top;
-            this._core.store.state.pointerX = (xRelativeToHost - this._core.store.state.translateX) / this._core.store.state.scale;
-            this._core.store.state.pointerY = (yRelativeToHost - this._core.store.state.translateY) / this._core.store.state.scale;
-            this._core.store.state.objects?.updateCursorPosition(this._core.store.state.pointerX, this._core.store.state.pointerY);
             const activePointers = Array.from(this._core.store.state.pointers.values());
+            if (this._core.store.state.isScaling || activePointers.length > 1) {
+                this._core.store.state.objects?.clearCursorPosition();
+            }
+            else {
+                this._core.store.state.pointerX = (xRelativeToHost - this._core.store.state.translateX) / this._core.store.state.scale;
+                this._core.store.state.pointerY = (yRelativeToHost - this._core.store.state.translateY) / this._core.store.state.scale;
+                if (!this._touchCursorBroadcastActive) {
+                    const dx = event.clientX - this._touchStartScreenX;
+                    const dy = event.clientY - this._touchStartScreenY;
+                    if (Math.sqrt(dx * dx + dy * dy) >= KritzelViewport.TOUCH_CURSOR_BROADCAST_THRESHOLD) {
+                        this._touchCursorBroadcastActive = true;
+                    }
+                }
+                if (this._touchCursorBroadcastActive) {
+                    this._core.store.state.objects?.updateCursorPosition(this._core.store.state.pointerX, this._core.store.state.pointerY);
+                }
+            }
             if (activePointers.length === 2) {
                 const firstTouchX = activePointers[0].clientX - this._core.store.offsetX;
                 const firstTouchY = activePointers[0].clientY - this._core.store.offsetY;
@@ -264,6 +292,7 @@ export class KritzelViewport {
             }
         }
         if (event.pointerType === 'touch' || event.pointerType === 'pen') {
+            this._touchCursorBroadcastActive = false;
             if (this._core.store.state.pointers.size === 0) {
                 this._debounceEndScaling();
             }

package/dist/collection/classes/managers/anchor.manager.js

@@ -286,16 +286,22 @@ export class KritzelAnchorManager {
         if (!KritzelClassHelper.isInstanceOf(selectedObject, 'KritzelLine'))
             return null;
         const line = selectedObject;
-        const startAnchorViz = this.computeAnchorVisualization(line, 'start');
-        const endAnchorViz = this.computeAnchorVisualization(line, 'end');
+        const startAnchorVizRaw = this.computeAnchorVisualization(line, 'start');
+        const endAnchorVizRaw = this.computeAnchorVisualization(line, 'end');
+        const startAnchorViz = this.isFiniteAnchorVisualization(startAnchorVizRaw) ? startAnchorVizRaw : null;
+        const endAnchorViz = this.isFiniteAnchorVisualization(endAnchorVizRaw) ? endAnchorVizRaw : null;
         if (!startAnchorViz && !endAnchorViz)
             return null;
-        const scale = this._core.store.state.scale;
-        const lineStrokeWidth = line.strokeWidth / line.scale;
+        const scale = this.getSafeScale(this._core.store.state.scale);
+        const lineScale = this.getSafeScale(line.scale);
+        const lineStrokeWidth = line.strokeWidth / lineScale;
         const indicatorStrokeWidth = `${2 / scale}`;
         const dashLength = Math.max(lineStrokeWidth * 2, 4 / scale);
         const dashArray = `${dashLength} ${dashLength}`;
         const indicatorRadius = 8 / scale;
+        if (!this.areFiniteNumbers(lineStrokeWidth, dashLength, indicatorRadius)) {
+            return null;
+        }
         return {
             lineStrokeWidth,
             indicatorStrokeWidth,
@@ -317,31 +323,39 @@ export class KritzelAnchorManager {
         const snapCandidate = this.getSnapCandidate();
         if (!snapCandidate)
             return null;
-        const scale = this._core.store.state.scale;
+        if (!this.areFiniteNumbers(snapCandidate.centerX, snapCandidate.centerY, snapCandidate.lineEndpointX, snapCandidate.lineEndpointY)) {
+            return null;
+        }
+        const scale = this.getSafeScale(this._core.store.state.scale);
         const indicatorRadius = 8 / scale;
         const indicatorStrokeWidth = `${2 / scale}`;
-        const lineStrokeWidth = snapCandidate.lineStrokeWidth
-            ? `${snapCandidate.lineStrokeWidth}`
-            : `${4 / scale}`;
-        const lineStrokeWidthNum = snapCandidate.lineStrokeWidth || (4 / scale);
+        const lineStrokeWidthNum = this.areFiniteNumbers(snapCandidate.lineStrokeWidth) && snapCandidate.lineStrokeWidth > 0
+            ? snapCandidate.lineStrokeWidth
+            : (4 / scale);
+        const lineStrokeWidth = `${lineStrokeWidthNum}`;
         const dashLength = Math.max(lineStrokeWidthNum * 2, 4 / scale);
         const dashArray = `${dashLength} ${dashLength}`;
         const lineStroke = snapCandidate.lineStroke || '#000000';
-        let solidLineEndX = snapCandidate.edgeX;
-        let solidLineEndY = snapCandidate.edgeY;
+        let edgeX = this.areFiniteNumbers(snapCandidate.edgeX) ? snapCandidate.edgeX : undefined;
+        let edgeY = this.areFiniteNumbers(snapCandidate.edgeY) ? snapCandidate.edgeY : undefined;
+        let solidLineEndX = edgeX;
+        let solidLineEndY = edgeY;
         let arrowPoints;
-        if (snapCandidate.arrowOffset && snapCandidate.edgeX !== undefined && snapCandidate.edgeY !== undefined) {
-            const dx = snapCandidate.lineEndpointX - snapCandidate.edgeX;
-            const dy = snapCandidate.lineEndpointY - snapCandidate.edgeY;
+        const arrowOffset = this.areFiniteNumbers(snapCandidate.arrowOffset) && snapCandidate.arrowOffset > 0
+            ? snapCandidate.arrowOffset
+            : undefined;
+        if (arrowOffset !== undefined && edgeX !== undefined && edgeY !== undefined) {
+            const dx = snapCandidate.lineEndpointX - edgeX;
+            const dy = snapCandidate.lineEndpointY - edgeY;
             const length = Math.sqrt(dx * dx + dy * dy);
-            if (length > snapCandidate.arrowOffset) {
-                solidLineEndX = snapCandidate.edgeX + (dx / length) * snapCandidate.arrowOffset;
-                solidLineEndY = snapCandidate.edgeY + (dy / length) * snapCandidate.arrowOffset;
+            if (length > arrowOffset) {
+                solidLineEndX = edgeX + (dx / length) * arrowOffset;
+                solidLineEndY = edgeY + (dy / length) * arrowOffset;
             }
             // Calculate arrow head points
             // Direction from line endpoint to edge (arrow direction)
-            const arrowDx = snapCandidate.edgeX - snapCandidate.lineEndpointX;
-            const arrowDy = snapCandidate.edgeY - snapCandidate.lineEndpointY;
+            const arrowDx = edgeX - snapCandidate.lineEndpointX;
+            const arrowDy = edgeY - snapCandidate.lineEndpointY;
             const arrowLengthTotal = Math.sqrt(arrowDx * arrowDx + arrowDy * arrowDy);
             if (arrowLengthTotal > 0) {
                 const ux = arrowDx / arrowLengthTotal;
@@ -350,11 +364,11 @@ export class KritzelAnchorManager {
                 const px = -uy;
                 const py = ux;
                 // Arrow dimensions
-                const arrowLength = snapCandidate.arrowOffset;
+                const arrowLength = arrowOffset;
                 const arrowWidth = arrowLength; // 1:1 ratio
                 // Arrow tip at edge
-                const tipX = snapCandidate.edgeX;
-                const tipY = snapCandidate.edgeY;
+                const tipX = edgeX;
+                const tipY = edgeY;
                 // Arrow base
                 const baseX = tipX - ux * arrowLength;
                 const baseY = tipY - uy * arrowLength;
@@ -363,9 +377,31 @@ export class KritzelAnchorManager {
                 const leftY = baseY + py * arrowWidth / 2;
                 const rightX = baseX - px * arrowWidth / 2;
                 const rightY = baseY - py * arrowWidth / 2;
-                arrowPoints = `${tipX},${tipY} ${leftX},${leftY} ${rightX},${rightY}`;
+                if (this.areFiniteNumbers(tipX, tipY, leftX, leftY, rightX, rightY)) {
+                    arrowPoints = `${tipX},${tipY} ${leftX},${leftY} ${rightX},${rightY}`;
+                }
             }
         }
+        if (!this.areFiniteNumbers(indicatorRadius, lineStrokeWidthNum, dashLength)) {
+            return null;
+        }
+        const snapLinePath = (() => {
+            if (snapCandidate.controlX !== undefined &&
+                snapCandidate.controlY !== undefined &&
+                snapCandidate.t !== undefined &&
+                this.areFiniteNumbers(snapCandidate.controlX, snapCandidate.controlY, snapCandidate.t)) {
+                const startT = snapCandidate.endpoint === 'start' ? 1 - snapCandidate.t : snapCandidate.t;
+                // Ensure meaningful range
+                if (startT >= 1)
+                    return undefined;
+                const segment = this.extractQuadraticSegment({ x: snapCandidate.lineEndpointX, y: snapCandidate.lineEndpointY }, { x: snapCandidate.controlX, y: snapCandidate.controlY }, { x: snapCandidate.centerX, y: snapCandidate.centerY }, startT, 1);
+                if (!this.areFiniteNumbers(segment.start.x, segment.start.y, segment.control.x, segment.control.y, segment.end.x, segment.end.y)) {
+                    return undefined;
+                }
+                return `M ${segment.start.x} ${segment.start.y} Q ${segment.control.x} ${segment.control.y} ${segment.end.x} ${segment.end.y}`;
+            }
+            return undefined;
+        })();
         return {
             indicatorRadius,
             indicatorStrokeWidth,
@@ -376,27 +412,15 @@ export class KritzelAnchorManager {
             centerY: snapCandidate.centerY,
             lineEndpointX: snapCandidate.lineEndpointX,
             lineEndpointY: snapCandidate.lineEndpointY,
-            edgeX: snapCandidate.edgeX,
-            edgeY: snapCandidate.edgeY,
-            arrowOffset: snapCandidate.arrowOffset,
+            edgeX,
+            edgeY,
+            arrowOffset,
             arrowStyle: snapCandidate.arrowStyle,
             arrowFill: snapCandidate.arrowFill,
             solidLineEndX,
             solidLineEndY,
             arrowPoints,
-            snapLinePath: (() => {
-                if (snapCandidate.controlX !== undefined &&
-                    snapCandidate.controlY !== undefined &&
-                    snapCandidate.t !== undefined) {
-                    const startT = snapCandidate.endpoint === 'start' ? 1 - snapCandidate.t : snapCandidate.t;
-                    // Ensure meaningful range
-                    if (startT >= 1)
-                        return undefined;
-                    const segment = this.extractQuadraticSegment({ x: snapCandidate.lineEndpointX, y: snapCandidate.lineEndpointY }, { x: snapCandidate.controlX, y: snapCandidate.controlY }, { x: snapCandidate.centerX, y: snapCandidate.centerY }, startT, 1);
-                    return `M ${segment.start.x} ${segment.start.y} Q ${segment.control.x} ${segment.control.y} ${segment.end.x} ${segment.end.y}`;
-                }
-                return undefined;
-            })(),
+            snapLinePath,
         };
     }
     // ============================================
@@ -574,12 +598,19 @@ export class KritzelAnchorManager {
             return null;
         const centerX = targetObject.centerX;
         const centerY = targetObject.centerY;
+        if (!this.areFiniteNumbers(clipInfo.worldX, clipInfo.worldY, centerX, centerY)) {
+            return null;
+        }
+        const pathD = this.buildAnchorPath(line, endpoint, clipInfo, targetObject) ?? undefined;
+        if (pathD && !this.isFinitePathData(pathD)) {
+            return null;
+        }
         return {
             edgeX: clipInfo.worldX,
             edgeY: clipInfo.worldY,
             centerX,
             centerY,
-            pathD: this.buildAnchorPath(line, endpoint, clipInfo, targetObject) ?? undefined,
+            pathD,
         };
     }
     /**
@@ -1292,9 +1323,10 @@ export class KritzelAnchorManager {
         const sin = Math.sin(line.rotation);
         const rotatedX = (px - cx) * cos - (py - cy) * sin + cx;
         const rotatedY = (px - cx) * sin + (py - cy) * cos + cy;
+        const safeLineScale = this.getSafeScale(line.scale);
         return {
-            x: rotatedX / line.scale + line.translateX,
-            y: rotatedY / line.scale + line.translateY,
+            x: rotatedX / safeLineScale + line.translateX,
+            y: rotatedY / safeLineScale + line.translateY,
         };
     }
     /**
@@ -1308,8 +1340,9 @@ export class KritzelAnchorManager {
      * @returns Object with x and y coordinates in the line's local SVG space.
      */
     lineWorldToLocal(line, worldX, worldY) {
-        const dx = (worldX - line.translateX) * line.scale;
-        const dy = (worldY - line.translateY) * line.scale;
+        const safeLineScale = this.getSafeScale(line.scale);
+        const dx = (worldX - line.translateX) * safeLineScale;
+        const dy = (worldY - line.translateY) * safeLineScale;
         const cx = line.totalWidth / 2;
         const cy = line.totalHeight / 2;
         const cos = Math.cos(-line.rotation);
@@ -1321,6 +1354,30 @@ export class KritzelAnchorManager {
             y: rotatedY + line.y,
         };
     }
+    getSafeScale(scale) {
+        if (Number.isFinite(scale) && Math.abs(scale) > 1e-6) {
+            return scale;
+        }
+        return 1;
+    }
+    areFiniteNumbers(...values) {
+        return values.every(value => value !== undefined && Number.isFinite(value));
+    }
+    isFiniteAnchorVisualization(visualization) {
+        if (!visualization) {
+            return false;
+        }
+        if (!this.areFiniteNumbers(visualization.edgeX, visualization.edgeY, visualization.centerX, visualization.centerY)) {
+            return false;
+        }
+        if (visualization.pathD && !this.isFinitePathData(visualization.pathD)) {
+            return false;
+        }
+        return true;
+    }
+    isFinitePathData(pathD) {
+        return !pathD.includes('Infinity') && !pathD.includes('NaN');
+    }
     /**
      * Checks if an object can be used as an anchor target.
      * Excludes selection-related objects (SelectionBox, SelectionGroup) and

package/dist/collection/classes/providers/broadcast-sync-provider.class.js

@@ -6,6 +6,7 @@ import * as decoding from "lib0/decoding";
  * This is a lightweight alternative to y-webrtc for browser-tab-only sync
  */
 export class BroadcastSyncProvider {
+    type = 'local';
     doc;
     channel;
     _synced = false;
@@ -87,6 +88,10 @@ export class BroadcastSyncProvider {
     disconnect() {
         // BroadcastChannel doesn't have explicit disconnect
     }
+    async reconnect() {
+        this.disconnect();
+        return this.connect();
+    }
     destroy() {
         this.doc.off('update', this.handleDocUpdate);
         this.channel.close();