@mindexec/cli 0.2.482 → 0.2.483

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.482",
+  "version": "0.2.483",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

package/wwwroot/_content/MindExecution.Shared/js/mind-map-automation-edge-motion.js

@@ -17,10 +17,39 @@
     function buildEdgePathData(source, target) {
         const deltaX = target.x - source.x;
         const absDeltaX = Math.abs(deltaX);
-        const direction = deltaX < 0 ? -1 : 1;
-        const handleDistance = Math.min(180, Math.max(12, absDeltaX * 0.38), Math.max(0, absDeltaX * 0.45));
-        const signedHandleDistance = direction * handleDistance;
-        return `M ${source.x.toFixed(1)} ${source.y.toFixed(1)} C ${(source.x + signedHandleDistance).toFixed(1)} ${source.y.toFixed(1)}, ${(target.x - signedHandleDistance).toFixed(1)} ${target.y.toFixed(1)}, ${target.x.toFixed(1)} ${target.y.toFixed(1)}`;
+        const handleDistance = deltaX < 0
+            ? Math.min(260, Math.max(84, absDeltaX * 0.22, Math.abs(target.y - source.y) * 0.35))
+            : Math.min(180, Math.max(12, absDeltaX * 0.38), Math.max(0, absDeltaX * 0.45));
+        return `M ${source.x.toFixed(1)} ${source.y.toFixed(1)} C ${(source.x + handleDistance).toFixed(1)} ${source.y.toFixed(1)}, ${(target.x - handleDistance).toFixed(1)} ${target.y.toFixed(1)}, ${target.x.toFixed(1)} ${target.y.toFixed(1)}`;
+    }
+
+    function buildRoundedRoutePathData(points, radius = 12) {
+        if (!Array.isArray(points) || points.length < 2) {
+            return '';
+        }
+
+        const commands = [`M ${points[0].x.toFixed(1)} ${points[0].y.toFixed(1)}`];
+        for (let index = 1; index < points.length - 1; index += 1) {
+            const previous = points[index - 1];
+            const current = points[index];
+            const next = points[index + 1];
+            const incomingLength = Math.abs(current.x - previous.x) + Math.abs(current.y - previous.y);
+            const outgoingLength = Math.abs(next.x - current.x) + Math.abs(next.y - current.y);
+            const cornerRadius = Math.min(radius, incomingLength / 2, outgoingLength / 2);
+            const before = {
+                x: current.x - Math.sign(current.x - previous.x) * cornerRadius,
+                y: current.y - Math.sign(current.y - previous.y) * cornerRadius
+            };
+            const after = {
+                x: current.x + Math.sign(next.x - current.x) * cornerRadius,
+                y: current.y + Math.sign(next.y - current.y) * cornerRadius
+            };
+            commands.push(`L ${before.x.toFixed(1)} ${before.y.toFixed(1)}`);
+            commands.push(`Q ${current.x.toFixed(1)} ${current.y.toFixed(1)} ${after.x.toFixed(1)} ${after.y.toFixed(1)}`);
+        }
+        const finalPoint = points[points.length - 1];
+        commands.push(`L ${finalPoint.x.toFixed(1)} ${finalPoint.y.toFixed(1)}`);
+        return commands.join(' ');
     }
 
     function getCachedViewportMetrics(module) {
@@ -96,7 +125,14 @@
             return false;
         }
 
-        const pathData = buildEdgePathData(source, target);
+        const routePoints = Array.isArray(item.motionRoutePoints)
+            ? item.motionRoutePoints
+                .map(point => transformPoint(point, scale, offsetX, offsetY))
+                .filter(Boolean)
+            : null;
+        const pathData = routePoints?.length >= 2
+            ? buildRoundedRoutePathData(routePoints)
+            : buildEdgePathData(source, target);
         setSvgAttributes(item.hitPath, { d: pathData });
         setSvgAttributes(item.path, { d: pathData });
         setSvgAttributes(item.sourceDot, { cx: source.x.toFixed(1), cy: source.y.toFixed(1) });

package/wwwroot/_content/MindExecution.Shared/js/mind-map-automation-edge-routing.js

@@ -0,0 +1,400 @@
+// File: mind-map-automation-edge-routing.js
+// Settled business-automation edge routing kept separate from the CSS3D runtime.
+(function registerMindMapAutomationEdgeRouting(global) {
+    'use strict';
+
+    function buildRoute(source, target, obstacles = []) {
+        obstacles = selectRelevantBusinessAutomationRoutingObstacles(source, target, obstacles);
+        const deltaX = target.x - source.x;
+        const absDeltaX = Math.abs(deltaX);
+        const handleDistance = deltaX < 0
+            ? Math.min(260, Math.max(84, absDeltaX * 0.22, Math.abs(target.y - source.y) * 0.35))
+            : Math.min(180, Math.max(12, absDeltaX * 0.38), Math.max(0, absDeltaX * 0.45));
+
+        // Folded room islands can legitimately place a later stage to the
+        // left. Keep both handles outside their cards so the connector loops
+        // around the island instead of diving back through intervening nodes.
+        const firstControl = { x: source.x + handleDistance, y: source.y };
+        const secondControl = { x: target.x - handleDistance, y: target.y };
+        const cubicPoints = [];
+        for (let segment = 0; segment <= 12; segment += 1) {
+            const t = segment / 12;
+            const inverse = 1 - t;
+            const inverseSquared = inverse * inverse;
+            const tSquared = t * t;
+            cubicPoints.push({
+                x: inverseSquared * inverse * source.x
+                    + 3 * inverseSquared * t * firstControl.x
+                    + 3 * inverse * tSquared * secondControl.x
+                    + tSquared * t * target.x,
+                y: inverseSquared * inverse * source.y
+                    + 3 * inverseSquared * t * firstControl.y
+                    + 3 * inverse * tSquared * secondControl.y
+                    + tSquared * t * target.y
+            });
+        }
+        const cubicPathData = `M ${source.x.toFixed(1)} ${source.y.toFixed(1)} C ${firstControl.x.toFixed(1)} ${source.y.toFixed(1)}, ${secondControl.x.toFixed(1)} ${target.y.toFixed(1)}, ${target.x.toFixed(1)} ${target.y.toFixed(1)}`;
+        if (isRouteClear(cubicPoints, obstacles)) {
+            return { pathData: cubicPathData, points: null, blocked: false };
+        }
+
+        const clearance = 18;
+        const left = Math.min(source.x, target.x, ...obstacles.map(rect => rect.x));
+        const right = Math.max(source.x, target.x, ...obstacles.map(rect => rect.x + rect.width));
+        const top = Math.min(source.y, target.y, ...obstacles.map(rect => rect.y));
+        const bottom = Math.max(source.y, target.y, ...obstacles.map(rect => rect.y + rect.height));
+        const obstacleChannels = obstacles.flatMap(rect => [rect.x - clearance, rect.x + rect.width + clearance]);
+        const sourceExitCandidates = Array.from(new Set([
+            source.x + clearance,
+            right + clearance,
+            ...obstacleChannels.filter(value => value >= source.x + clearance - 0.01)
+        ]))
+            .sort((a, b) => Math.abs(a - source.x) - Math.abs(b - source.x))
+            .slice(0, 12);
+        const targetEntryCandidates = Array.from(new Set([
+            target.x - clearance,
+            left - clearance,
+            ...obstacleChannels.filter(value => value <= target.x - clearance + 0.01)
+        ]))
+            .sort((a, b) => Math.abs(a - target.x) - Math.abs(b - target.x))
+            .slice(0, 12);
+        const laneCandidates = Array.from(new Set([
+            top - clearance,
+            bottom + clearance,
+            ...obstacles.flatMap(rect => [rect.y - clearance, rect.y + rect.height + clearance])
+        ])).sort((a, b) => {
+            const distanceA = Math.min(Math.abs(a - source.y), Math.abs(a - target.y));
+            const distanceB = Math.min(Math.abs(b - source.y), Math.abs(b - target.y));
+            return distanceA - distanceB || a - b;
+        }).slice(0, 16);
+        const candidates = [];
+        sourceExitCandidates.forEach(sourceExitX => {
+            targetEntryCandidates.forEach(targetEntryX => {
+                laneCandidates.forEach(laneY => {
+                    const points = removeDuplicateRoutePoints([
+                        source,
+                        { x: sourceExitX, y: source.y },
+                        { x: sourceExitX, y: laneY },
+                        { x: targetEntryX, y: laneY },
+                        { x: targetEntryX, y: target.y },
+                        target
+                    ]);
+                    if (!isRouteClear(points, obstacles)) {
+                        return;
+                    }
+
+                    const length = points.slice(1).reduce((total, point, index) => (
+                        total
+                        + Math.abs(point.x - points[index].x)
+                        + Math.abs(point.y - points[index].y)
+                    ), 0);
+                    candidates.push({
+                        points,
+                        score: length + (points.length - 2) * 9,
+                        signature: points.map(point => `${point.x.toFixed(2)}:${point.y.toFixed(2)}`).join(',')
+                    });
+                });
+            });
+        });
+        candidates.sort((a, b) => a.score - b.score || a.signature.localeCompare(b.signature));
+        const best = candidates[0] || null;
+        if (best) {
+            return { pathData: buildRoundedRoutePathData(best.points), points: best.points, blocked: false };
+        }
+
+        const orthogonalPoints = buildOrthogonalRoute(source, target, obstacles, clearance);
+        return orthogonalPoints
+            ? { pathData: buildRoundedRoutePathData(orthogonalPoints), points: orthogonalPoints, blocked: false }
+            : { pathData: '', points: null, blocked: true };
+    }
+
+    function selectRelevantBusinessAutomationRoutingObstacles(source, target, obstacles) {
+        if (!Array.isArray(obstacles) || obstacles.length === 0) {
+            return [];
+        }
+
+        const margin = Math.max(120, Math.min(420, (Math.abs(target.x - source.x) + Math.abs(target.y - source.y)) * 0.3));
+        const left = Math.min(source.x, target.x) - margin;
+        const right = Math.max(source.x, target.x) + margin;
+        const top = Math.min(source.y, target.y) - margin;
+        const bottom = Math.max(source.y, target.y) + margin;
+        const centreX = (source.x + target.x) * 0.5;
+        const centreY = (source.y + target.y) * 0.5;
+        return obstacles
+            .filter(rect => rect.x < right
+                && rect.x + rect.width > left
+                && rect.y < bottom
+                && rect.y + rect.height > top)
+            .sort((first, second) => {
+                const firstX = first.x + first.width * 0.5;
+                const firstY = first.y + first.height * 0.5;
+                const secondX = second.x + second.width * 0.5;
+                const secondY = second.y + second.height * 0.5;
+                const firstDistance = Math.abs(firstX - centreX) + Math.abs(firstY - centreY);
+                const secondDistance = Math.abs(secondX - centreX) + Math.abs(secondY - centreY);
+                return firstDistance - secondDistance
+                    || String(first.nodeId || '').localeCompare(String(second.nodeId || ''));
+            })
+            .slice(0, 32);
+    }
+
+    function buildOrthogonalRoute(source, target, obstacles, clearance) {
+        const start = { x: source.x + clearance, y: source.y };
+        const goal = { x: target.x - clearance, y: target.y };
+        if (!isRouteClear([source, start], obstacles)
+            || !isRouteClear([goal, target], obstacles)) {
+            return null;
+        }
+
+        const xCoordinates = Array.from(new Set([
+            start.x,
+            goal.x,
+            ...obstacles.flatMap(rect => [rect.x - clearance, rect.x + rect.width + clearance])
+        ])).sort((a, b) => a - b);
+        const yCoordinates = Array.from(new Set([
+            start.y,
+            goal.y,
+            ...obstacles.flatMap(rect => [rect.y - clearance, rect.y + rect.height + clearance])
+        ])).sort((a, b) => a - b);
+        const startX = xCoordinates.indexOf(start.x);
+        const startY = yCoordinates.indexOf(start.y);
+        const goalX = xCoordinates.indexOf(goal.x);
+        const goalY = yCoordinates.indexOf(goal.y);
+        if (startX < 0 || startY < 0 || goalX < 0 || goalY < 0) {
+            return null;
+        }
+
+        const pointIsClear = (xIndex, yIndex) => {
+            const x = xCoordinates[xIndex];
+            const y = yCoordinates[yIndex];
+            return !obstacles.some(rect => x > rect.x + 0.01
+                && x < rect.x + rect.width - 0.01
+                && y > rect.y + 0.01
+                && y < rect.y + rect.height - 0.01);
+        };
+        const segmentIsClear = (fromX, fromY, toX, toY) => isRouteClear([
+            { x: xCoordinates[fromX], y: yCoordinates[fromY] },
+            { x: xCoordinates[toX], y: yCoordinates[toY] }
+        ], obstacles);
+        const stateKey = (x, y, direction) => `${x}|${y}|${direction}`;
+        const compareQueueEntries = (first, second) => first.cost - second.cost
+            || first.x - second.x
+            || first.y - second.y
+            || first.direction - second.direction;
+        const queue = [];
+        const queuePush = entry => {
+            queue.push(entry);
+            let index = queue.length - 1;
+            while (index > 0) {
+                const parent = Math.floor((index - 1) / 2);
+                if (compareQueueEntries(queue[parent], queue[index]) <= 0) break;
+                [queue[parent], queue[index]] = [queue[index], queue[parent]];
+                index = parent;
+            }
+        };
+        const queuePop = () => {
+            if (queue.length === 0) return null;
+            const first = queue[0];
+            const last = queue.pop();
+            if (queue.length > 0 && last) {
+                queue[0] = last;
+                let index = 0;
+                while (true) {
+                    const left = index * 2 + 1;
+                    const right = left + 1;
+                    let best = index;
+                    if (left < queue.length && compareQueueEntries(queue[left], queue[best]) < 0) best = left;
+                    if (right < queue.length && compareQueueEntries(queue[right], queue[best]) < 0) best = right;
+                    if (best === index) break;
+                    [queue[index], queue[best]] = [queue[best], queue[index]];
+                    index = best;
+                }
+            }
+            return first;
+        };
+
+        const startKey = stateKey(startX, startY, 0);
+        const distances = new Map([[startKey, 0]]);
+        const previous = new Map();
+        queuePush({ x: startX, y: startY, direction: 0, cost: 0, key: startKey });
+        const moves = [
+            { dx: 1, dy: 0, direction: 1 },
+            { dx: -1, dy: 0, direction: 1 },
+            { dx: 0, dy: 1, direction: 2 },
+            { dx: 0, dy: -1, direction: 2 }
+        ];
+        let resolved = null;
+        while (queue.length > 0) {
+            const state = queuePop();
+            if (!state || state.cost > (distances.get(state.key) ?? Number.POSITIVE_INFINITY) + 0.001) continue;
+            if (state.x === goalX && state.y === goalY) {
+                resolved = state;
+                break;
+            }
+
+            moves.forEach(move => {
+                const nextX = state.x + move.dx;
+                const nextY = state.y + move.dy;
+                if (nextX < 0 || nextX >= xCoordinates.length || nextY < 0 || nextY >= yCoordinates.length
+                    || !pointIsClear(nextX, nextY)
+                    || !segmentIsClear(state.x, state.y, nextX, nextY)) {
+                    return;
+                }
+                const segmentLength = Math.abs(xCoordinates[nextX] - xCoordinates[state.x])
+                    + Math.abs(yCoordinates[nextY] - yCoordinates[state.y]);
+                const turnCost = state.direction !== 0 && state.direction !== move.direction ? 12 : 0;
+                const cost = state.cost + segmentLength + turnCost;
+                const key = stateKey(nextX, nextY, move.direction);
+                if ((distances.get(key) ?? Number.POSITIVE_INFINITY) <= cost + 0.001) return;
+                distances.set(key, cost);
+                previous.set(key, state);
+                queuePush({ x: nextX, y: nextY, direction: move.direction, cost, key });
+            });
+        }
+        if (!resolved) {
+            return null;
+        }
+
+        const reversed = [];
+        let cursor = resolved;
+        while (cursor) {
+            reversed.push({ x: xCoordinates[cursor.x], y: yCoordinates[cursor.y] });
+            if (cursor.key === startKey) break;
+            cursor = previous.get(cursor.key) || null;
+        }
+        reversed.reverse();
+        return simplifyOrthogonalRoute(removeDuplicateRoutePoints([
+            source,
+            start,
+            ...reversed,
+            goal,
+            target
+        ]));
+    }
+
+    function simplifyOrthogonalRoute(points) {
+        if (!Array.isArray(points) || points.length < 3) {
+            return points;
+        }
+        const simplified = [points[0]];
+        for (let index = 1; index < points.length - 1; index += 1) {
+            const previous = simplified[simplified.length - 1];
+            const current = points[index];
+            const next = points[index + 1];
+            const sameVertical = Math.abs(previous.x - current.x) < 0.01 && Math.abs(current.x - next.x) < 0.01;
+            const sameHorizontal = Math.abs(previous.y - current.y) < 0.01 && Math.abs(current.y - next.y) < 0.01;
+            if (!sameVertical && !sameHorizontal) {
+                simplified.push(current);
+            }
+        }
+        simplified.push(points[points.length - 1]);
+        return simplified;
+    }
+
+    function buildPathData(source, target) {
+        return buildRoute(source, target).pathData;
+    }
+
+    function removeDuplicateRoutePoints(points) {
+        const result = [];
+        points.forEach(point => {
+            const previous = result[result.length - 1];
+            if (previous && Math.abs(previous.x - point.x) < 0.01 && Math.abs(previous.y - point.y) < 0.01) {
+                return;
+            }
+            result.push({ x: Number(point.x), y: Number(point.y) });
+        });
+        return result;
+    }
+
+    function isRouteClear(points, obstacles) {
+        if (!Array.isArray(points) || points.length < 2) {
+            return false;
+        }
+        return !obstacles.some(rect => {
+            for (let index = 1; index < points.length; index += 1) {
+                if (doesSegmentIntersectRectInterior(points[index - 1], points[index], rect)) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+
+    function doesSegmentIntersectRectInterior(source, target, rect) {
+        const inset = 0.5;
+        const left = Number(rect.x) + inset;
+        const right = Number(rect.x) + Number(rect.width) - inset;
+        const top = Number(rect.y) + inset;
+        const bottom = Number(rect.y) + Number(rect.height) - inset;
+        if (!(left < right && top < bottom)) {
+            return false;
+        }
+        const inside = point => point.x > left && point.x < right && point.y > top && point.y < bottom;
+        if (inside(source) || inside(target)) {
+            return true;
+        }
+
+        const orientation = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+        const onSegment = (a, b, c) => b.x >= Math.min(a.x, c.x) - 0.0001
+            && b.x <= Math.max(a.x, c.x) + 0.0001
+            && b.y >= Math.min(a.y, c.y) - 0.0001
+            && b.y <= Math.max(a.y, c.y) + 0.0001;
+        const intersects = (a, b, c, d) => {
+            const first = orientation(a, b, c);
+            const second = orientation(a, b, d);
+            const third = orientation(c, d, a);
+            const fourth = orientation(c, d, b);
+            if (((first > 0.0001 && second < -0.0001) || (first < -0.0001 && second > 0.0001))
+                && ((third > 0.0001 && fourth < -0.0001) || (third < -0.0001 && fourth > 0.0001))) {
+                return true;
+            }
+            return (Math.abs(first) <= 0.0001 && onSegment(a, c, b))
+                || (Math.abs(second) <= 0.0001 && onSegment(a, d, b))
+                || (Math.abs(third) <= 0.0001 && onSegment(c, a, d))
+                || (Math.abs(fourth) <= 0.0001 && onSegment(c, b, d));
+        };
+        const topLeft = { x: left, y: top };
+        const topRight = { x: right, y: top };
+        const bottomRight = { x: right, y: bottom };
+        const bottomLeft = { x: left, y: bottom };
+        return intersects(source, target, topLeft, topRight)
+            || intersects(source, target, topRight, bottomRight)
+            || intersects(source, target, bottomRight, bottomLeft)
+            || intersects(source, target, bottomLeft, topLeft);
+    }
+
+    function buildRoundedRoutePathData(points, radius = 12) {
+        if (!Array.isArray(points) || points.length < 2) {
+            return '';
+        }
+        const commands = [`M ${points[0].x.toFixed(1)} ${points[0].y.toFixed(1)}`];
+        for (let index = 1; index < points.length - 1; index += 1) {
+            const previous = points[index - 1];
+            const current = points[index];
+            const next = points[index + 1];
+            const incomingLength = Math.abs(current.x - previous.x) + Math.abs(current.y - previous.y);
+            const outgoingLength = Math.abs(next.x - current.x) + Math.abs(next.y - current.y);
+            const cornerRadius = Math.min(radius, incomingLength / 2, outgoingLength / 2);
+            const before = {
+                x: current.x - Math.sign(current.x - previous.x) * cornerRadius,
+                y: current.y - Math.sign(current.y - previous.y) * cornerRadius
+            };
+            const after = {
+                x: current.x + Math.sign(next.x - current.x) * cornerRadius,
+                y: current.y + Math.sign(next.y - current.y) * cornerRadius
+            };
+            commands.push(`L ${before.x.toFixed(1)} ${before.y.toFixed(1)}`);
+            commands.push(`Q ${current.x.toFixed(1)} ${current.y.toFixed(1)} ${after.x.toFixed(1)} ${after.y.toFixed(1)}`);
+        }
+        const finalPoint = points[points.length - 1];
+        commands.push(`L ${finalPoint.x.toFixed(1)} ${finalPoint.y.toFixed(1)}`);
+        return commands.join(' ');
+    }
+
+    global.MindMapAutomationEdgeRouting = Object.freeze({
+        buildRoute,
+        buildPathData,
+        isRouteClear
+    });
+})(typeof window !== 'undefined' ? window : globalThis);

package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-manager.js

@@ -10762,6 +10762,33 @@
         return rects;
     }
 
+    function collectBusinessAutomationRoutingObstacles(module, containerRect, viewportWidth, viewportHeight) {
+        if (!(module?.nodeObjectsById instanceof Map)) {
+            return [];
+        }
+
+        const rects = [];
+        module.nodeObjectsById.forEach((entry, nodeId) => {
+            if (!entry?.model || entry.isVisibleInFrustum === false) {
+                return;
+            }
+
+            const residentFrame = getBusinessAutomationResidentNodeFrame(module, nodeId);
+            const rect = projectBusinessAutomationNodeOcclusionRect(
+                module,
+                entry,
+                containerRect,
+                viewportWidth,
+                viewportHeight,
+                residentFrame
+            );
+            if (rect) {
+                rects.push({ ...rect, nodeId: String(nodeId || '') });
+            }
+        });
+        return rects;
+    }
+
     function applyBusinessAutomationResidentOcclusionMask(visualLayer, visualGroup, module, containerRect, viewportWidth, viewportHeight) {
         if (!visualLayer || !visualGroup) {
             return;
@@ -11057,13 +11084,35 @@
         event.stopImmediatePropagation?.();
     }
 
-    function buildBusinessAutomationEdgePathData(source, target) {
+    function buildBusinessAutomationEdgeRoute(source, target, obstacles = []) {
+        const routing = window.MindMapAutomationEdgeRouting;
+        if (typeof routing?.buildRoute === 'function') {
+            return routing.buildRoute(source, target, obstacles);
+        }
+
+        // Loading the focused router is a release contract, but an omitted
+        // script must not crash the whole canvas. Fall back only for a direct
+        // unobstructed connector; obstacle-bearing routes fail closed.
+        if (Array.isArray(obstacles) && obstacles.length > 0) {
+            return { pathData: '', points: null, blocked: true };
+        }
+
         const deltaX = target.x - source.x;
         const absDeltaX = Math.abs(deltaX);
-        const direction = deltaX < 0 ? -1 : 1;
-        const handleDistance = Math.min(180, Math.max(12, absDeltaX * 0.38), Math.max(0, absDeltaX * 0.45));
-        const signedHandleDistance = direction * handleDistance;
-        return `M ${source.x.toFixed(1)} ${source.y.toFixed(1)} C ${(source.x + signedHandleDistance).toFixed(1)} ${source.y.toFixed(1)}, ${(target.x - signedHandleDistance).toFixed(1)} ${target.y.toFixed(1)}, ${target.x.toFixed(1)} ${target.y.toFixed(1)}`;
+        const handleDistance = deltaX < 0
+            ? Math.min(260, Math.max(84, absDeltaX * 0.22, Math.abs(target.y - source.y) * 0.35))
+            : Math.min(180, Math.max(12, absDeltaX * 0.38), Math.max(0, absDeltaX * 0.45));
+        const firstControl = { x: source.x + handleDistance, y: source.y };
+        const secondControl = { x: target.x - handleDistance, y: target.y };
+        return {
+            pathData: `M ${source.x.toFixed(1)} ${source.y.toFixed(1)} C ${firstControl.x.toFixed(1)} ${source.y.toFixed(1)}, ${secondControl.x.toFixed(1)} ${target.y.toFixed(1)}, ${target.x.toFixed(1)} ${target.y.toFixed(1)}`,
+            points: null,
+            blocked: false
+        };
+    }
+
+    function buildBusinessAutomationEdgePathData(source, target) {
+        return buildBusinessAutomationEdgeRoute(source, target).pathData;
     }
 
     function getBusinessAutomationDraftTargetPoint(module, draft, containerRect) {
@@ -11179,7 +11228,7 @@
         item.targetDot?.remove?.();
     }
 
-    function updateBusinessAutomationEdgeItem(item, edge, pathData, source, target, theme, isContextEdge, isSelected, isRelationHighlighted, hitPointerEvents) {
+    function updateBusinessAutomationEdgeItem(item, edge, pathData, source, target, theme, isContextEdge, isSelected, isRelationHighlighted, hitPointerEvents, routePoints = null) {
         setBusinessAutomationSvgAttributes(item.hitPath, {
             d: pathData,
             class: 'mind-map-business-automation-edge-hit',
@@ -11224,6 +11273,9 @@
         });
         item.motionSource = { x: source.x, y: source.y };
         item.motionTarget = { x: target.x, y: target.y };
+        item.motionRoutePoints = Array.isArray(routePoints)
+            ? routePoints.map(point => ({ x: Number(point.x), y: Number(point.y) }))
+            : null;
         item.motionVisible = true;
         setBusinessAutomationSvgElementsVisible([item.hitPath, item.path, item.sourceDot, item.targetDot], true);
     }
@@ -11256,6 +11308,7 @@
         const containerRect = module.container.getBoundingClientRect();
         const width = Math.max(1, Math.round(containerRect.width || 1));
         const height = Math.max(1, Math.round(containerRect.height || 1));
+        const routingObstacles = collectBusinessAutomationRoutingObstacles(module, containerRect, width, height);
         recordBusinessAutomationEdgeCameraState(module, width, height);
         for (const layer of [visualLayer, hitLayer]) {
             setBusinessAutomationSvgAttributes(layer, {
@@ -11335,12 +11388,26 @@
                 : isWorkerEdge
                 ? AUTOMATION_WORKER_PIN_THEME
                 : getAutomationPinTheme(sourceType);
-            const pathData = buildBusinessAutomationEdgePathData(source, target);
+            const route = buildBusinessAutomationEdgeRoute(
+                source,
+                target,
+                routingObstacles.filter(rect => rect.nodeId !== String(edge.sourceNodeId || '')
+                    && rect.nodeId !== String(edge.targetNodeId || ''))
+            );
+            const pathData = route.pathData;
+            if (route.blocked === true || !pathData) {
+                const existing = renderState.edgeItems.get(edgeId);
+                if (existing) {
+                    existing.motionVisible = false;
+                    setBusinessAutomationSvgElementsVisible([existing.hitPath, existing.path, existing.sourceDot, existing.targetDot], false);
+                }
+                continue;
+            }
             const isSelected = String(edge.id || '') === _businessAutomationSelectedEdgeId;
             const isRelationHighlighted = relationContext?.edgeIds?.has?.(String(edge.id || '').trim()) === true;
             const hitPointerEvents = _businessAutomationConnectionDraft ? 'none' : 'stroke';
             const item = ensureBusinessAutomationEdgeItem(renderState, edgeId);
-            updateBusinessAutomationEdgeItem(item, edge, pathData, source, target, theme, isReferenceEdge, isSelected, isRelationHighlighted, hitPointerEvents);
+            updateBusinessAutomationEdgeItem(item, edge, pathData, source, target, theme, isReferenceEdge, isSelected, isRelationHighlighted, hitPointerEvents, route.points);
             liveEdgeIds.add(edgeId);
         }
 

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-G3h1Bw32VT2isfx70lg1F1v94ewdn/kwAWOD4zpsU0U=",
+    "hash": "sha256-VyYJMbhTNysenfG7hYUM60kwM/91meEc0+JAIXAd4MA=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -61,7 +61,7 @@
       "System.Collections.Immutable.ap9596utv5.dll": "System.Collections.Immutable.dll",
       "System.Collections.NonGeneric.npjkaz40oc.dll": "System.Collections.NonGeneric.dll",
       "System.Collections.Specialized.ugkjbs6p02.dll": "System.Collections.Specialized.dll",
-      "System.Collections.zyvbaq6mpd.dll": "System.Collections.dll",
+      "System.Collections.3iuoxbe8my.dll": "System.Collections.dll",
       "System.ComponentModel.Annotations.clwo0z2oyu.dll": "System.ComponentModel.Annotations.dll",
       "System.ComponentModel.Primitives.end4v0xe2c.dll": "System.ComponentModel.Primitives.dll",
       "System.ComponentModel.TypeConverter.tgtp5sm4iv.dll": "System.ComponentModel.TypeConverter.dll",
@@ -121,19 +121,19 @@
       "System.Xml.XDocument.sn51jas17n.dll": "System.Xml.XDocument.dll",
       "System.brmz7yk5qh.dll": "System.dll",
       "netstandard.b50t77veor.dll": "netstandard.dll",
-      "System.Private.CoreLib.wflwsce1yq.dll": "System.Private.CoreLib.dll",
-      "MindExecution.Core.l639gk1bj0.dll": "MindExecution.Core.dll",
-      "MindExecution.Kernel.dhkjql36qa.dll": "MindExecution.Kernel.dll",
-      "MindExecution.Plugins.Admin.sdnqjd3bhw.dll": "MindExecution.Plugins.Admin.dll",
-      "MindExecution.Plugins.Business.dntgcr4fyr.dll": "MindExecution.Plugins.Business.dll",
-      "MindExecution.Plugins.Concept.jiz294lahg.dll": "MindExecution.Plugins.Concept.dll",
-      "MindExecution.Plugins.Directory.v0qvphgk63.dll": "MindExecution.Plugins.Directory.dll",
-      "MindExecution.Plugins.PlanMaster.mvfl14g6r9.dll": "MindExecution.Plugins.PlanMaster.dll",
-      "MindExecution.Plugins.YouTube.e5ui1py8ia.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.4pev6youhl.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.vzu3nwlp2r.dll": "MindExecution.Web.dll",
+      "System.Private.CoreLib.7s8wte759y.dll": "System.Private.CoreLib.dll",
+      "MindExecution.Core.zs4n1f9hjc.dll": "MindExecution.Core.dll",
+      "MindExecution.Kernel.l9idvg7mp7.dll": "MindExecution.Kernel.dll",
+      "MindExecution.Plugins.Admin.l37qx5d8zi.dll": "MindExecution.Plugins.Admin.dll",
+      "MindExecution.Plugins.Business.d7b282yazn.dll": "MindExecution.Plugins.Business.dll",
+      "MindExecution.Plugins.Concept.iw98n0qz5k.dll": "MindExecution.Plugins.Concept.dll",
+      "MindExecution.Plugins.Directory.cqgn6pa8di.dll": "MindExecution.Plugins.Directory.dll",
+      "MindExecution.Plugins.PlanMaster.j8xoa8nl57.dll": "MindExecution.Plugins.PlanMaster.dll",
+      "MindExecution.Plugins.YouTube.zvpzk7om4z.dll": "MindExecution.Plugins.YouTube.dll",
+      "MindExecution.Shared.ovot7q606x.dll": "MindExecution.Shared.dll",
+      "MindExecution.Web.bzuaz35jv0.dll": "MindExecution.Web.dll",
       "dotnet.native.566r55w3xu.js": "dotnet.native.js",
-      "dotnet.native.x6q5aixc38.wasm": "dotnet.native.wasm",
+      "dotnet.native.60hhmnxyoo.wasm": "dotnet.native.wasm",
       "dotnet.js": "dotnet.js",
       "dotnet.runtime.opaiwunc3t.js": "dotnet.runtime.js",
       "icudt_CJK.tjcz0u77k5.dat": "icudt_CJK.dat",
@@ -147,7 +147,7 @@
       "dotnet.runtime.opaiwunc3t.js": "sha256-vM4cfmuAtxs/dLoxiTCzPyPCyNkwOJu14cp6lXv3Sak="
     },
     "wasmNative": {
-      "dotnet.native.x6q5aixc38.wasm": "sha256-JwqtZ6eQSm3ZoJ66YvMQloK1Oydj3T6smTFv8wLfh7g="
+      "dotnet.native.60hhmnxyoo.wasm": "sha256-VpLSM7+jVkgAxK0IdGVTMs1H8WAqeTX3Qqjhf85yP0s="
     },
     "icu": {
       "icudt_CJK.tjcz0u77k5.dat": "sha256-SZLtQnRc0JkwqHab0VUVP7T3uBPSeYzxzDnpxPpUnHk=",
@@ -156,7 +156,7 @@
     },
     "coreAssembly": {
       "System.Runtime.InteropServices.JavaScript.pn2wvizzet.dll": "sha256-dczkyi5P7nETlP7roYWNE0BobJPm6wyt7Bc+ZhBu3NA=",
-      "System.Private.CoreLib.wflwsce1yq.dll": "sha256-dF/Q+yfJy5iZl9Auw+hkCG9FdPHTCzfL06D3ps9JZNw="
+      "System.Private.CoreLib.7s8wte759y.dll": "sha256-iSaryfzFI9zYnC5XopFpIBHr1sej8SGOWduSn1XMmvs="
     },
     "assembly": {
       "Google.Protobuf.9h59ukbel7.dll": "sha256-A541k1abRTWr6MqmCXfGDYcKHirypJS19mzPQu3lJt0=",
@@ -217,7 +217,7 @@
       "System.Collections.Immutable.ap9596utv5.dll": "sha256-op5xSkGyOSKVhFHn5U0j7SiJ3WEPLqA02/ss1NKf2Yg=",
       "System.Collections.NonGeneric.npjkaz40oc.dll": "sha256-y5bX6NSbxA8o7EJ9C0vujUNU93Wd2UhdpA5+C8WpRPY=",
       "System.Collections.Specialized.ugkjbs6p02.dll": "sha256-opanE88Yp6SrsrXZ9LaqM1diY8Q0jMrG3jvYM8v3Rao=",
-      "System.Collections.zyvbaq6mpd.dll": "sha256-ZbcBWmgkYTGdeU2GzVkRs8SERVp8OCUrNQFKiPseGb0=",
+      "System.Collections.3iuoxbe8my.dll": "sha256-a103KEA3xZ0tBaSi99B7VXuEscpr6RMGe1/eFNuz670=",
       "System.ComponentModel.Annotations.clwo0z2oyu.dll": "sha256-ALmLuW4qrS6x9RlN/Gl2e3DeAW9Ms8T9YcuoATYejvc=",
       "System.ComponentModel.Primitives.end4v0xe2c.dll": "sha256-Gi1I/XBckUQXoJLoNNMmz5spL9eqeCkS/D1vYEgV57g=",
       "System.ComponentModel.TypeConverter.tgtp5sm4iv.dll": "sha256-bdYu+4aR6MdkA7o/05m1kwDrWA4dxqHs1kRme5Xna24=",
@@ -276,18 +276,18 @@
       "System.Xml.XDocument.sn51jas17n.dll": "sha256-GNI2kFgFmPTwzuzwUn8gxK+AzGLUWRJFdg9JzIbrybQ=",
       "System.brmz7yk5qh.dll": "sha256-CfM2miyj1KHApFmqMdLYWio3S/jrdON2pW9Xr2nTwlo=",
       "netstandard.b50t77veor.dll": "sha256-//jQGOXjb8ET8WtXgOJrAxLx6E7zDJ5RjRRutwkvmxo=",
-      "MindExecution.Core.l639gk1bj0.dll": "sha256-o9dLvKGmstXiu50XUmRpwwsv/y81aA/NGRnKJy/1mks=",
-      "MindExecution.Kernel.dhkjql36qa.dll": "sha256-cWxc5rwjR4RYwAhGrlp5vxEiT7qneX2jrUTLWjL37CY=",
-      "MindExecution.Plugins.Business.dntgcr4fyr.dll": "sha256-GdIOYT2OuYdKorFOcfSWztPr8NIXddBdSj2kDJGORQw=",
-      "MindExecution.Plugins.Concept.jiz294lahg.dll": "sha256-SymfLnM0iJss9UJY7xGZXwfVzzl2NvfpKrrIVhmpW2I=",
-      "MindExecution.Plugins.PlanMaster.mvfl14g6r9.dll": "sha256-ovRoi3461C9eaSGfnBsDjS4EZKOZVhw3fLC7RELZUPU=",
-      "MindExecution.Shared.4pev6youhl.dll": "sha256-KOoTEe4T+zZNRFKjb8sO4/v/Q0X/ZQ8riPIs+8Nomak=",
-      "MindExecution.Web.vzu3nwlp2r.dll": "sha256-VblMDl0VAUvXDfnNtQPlWo00If/P1WCx7Bo7y2+prrQ="
+      "MindExecution.Core.zs4n1f9hjc.dll": "sha256-7XrZrL5PkRnemA1LjFguxgE7rqR8wOLZXdACUZG0MWg=",
+      "MindExecution.Kernel.l9idvg7mp7.dll": "sha256-uUzGo7hkUYV9pS1KkxLa5+9cFsVlHBGjV/9K0NYwl8Y=",
+      "MindExecution.Plugins.Business.d7b282yazn.dll": "sha256-x2oOQwLMyVaZxKffXxSG3RCoRjXlINsX90AHK9sLqQk=",
+      "MindExecution.Plugins.Concept.iw98n0qz5k.dll": "sha256-3kSdSqvBJAqTuy//MpLkJbupPx0hTSS3nL7nmpvyZFs=",
+      "MindExecution.Plugins.PlanMaster.j8xoa8nl57.dll": "sha256-Q9g9/Xs3dhJT+2RVAXb5ZoCT0ep5DeXYPy/8W5TWtvY=",
+      "MindExecution.Shared.ovot7q606x.dll": "sha256-zG0OUiZmgQ3P0BbT/fTv5PLjerpbYsHPyYB4qYl7l00=",
+      "MindExecution.Web.bzuaz35jv0.dll": "sha256-V7qhdSCSM+AG31Pc8swykgZwg1EN4Agz4VA/kCma+98="
     },
     "lazyAssembly": {
-      "MindExecution.Plugins.Admin.sdnqjd3bhw.dll": "sha256-4C8f3TLtj/VLuY9CpNvtPkWw5VtZl5ZnDe+Xq4d9LTU=",
-      "MindExecution.Plugins.Directory.v0qvphgk63.dll": "sha256-fzKMUnP4AFBBYkFh1IuhGyl7KMMkmCGKqlnPu4QBWUs=",
-      "MindExecution.Plugins.YouTube.e5ui1py8ia.dll": "sha256-Ii4ds8rpDHBAXVQKrb3AATbtF0MfTw51Iqu44nzVBx0="
+      "MindExecution.Plugins.Admin.l37qx5d8zi.dll": "sha256-cWsGhcCLF1k1nJxbJosjPxO4RwkkmEkW+SwPRqnIWhM=",
+      "MindExecution.Plugins.Directory.cqgn6pa8di.dll": "sha256-dB6SrNy6adA7R6ubKq0YDreLSzAA2ws0m13aFP/wWVc=",
+      "MindExecution.Plugins.YouTube.zvpzk7om4z.dll": "sha256-z31H/4EKYUcn0Ev09Yd1r9F9j6NvemCmjQzZhVHuehY="
     }
   },
   "cacheBootResources": true,

package/wwwroot/index.html

@@ -614,7 +614,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-            const scriptVersion = '20260824-css3d-viewport-owner-v985';
+            const scriptVersion = '20260824-compact-organic-v3-v986';
             const scriptUrl = (script) => `${base}${script}?v=${scriptVersion}`;
             console.log(`[Script Loader] Shared JS version: ${scriptVersion}`);
             const criticalScripts = [
@@ -632,6 +632,7 @@
                 'mind-map-remote-codecs.js',
                 'mind-map-css3d-hotpath.js',
                 'mind-map-image-policy.js',
+                'mind-map-automation-edge-routing.js',
                 'mind-map-automation-edge-motion.js',
                 'mind-map-css3d-manager.js',
                 'mind-map-object-manager.js',

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-  "version": "tcfcurmf",
+  "version": "Xc2iV1/U",
   "assets": [
     {
       "hash": "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -82,9 +82,13 @@ self.assetsManifest = {
       "url": "_content/MindExecution.Shared/js/mind-map-animated-image-preview.js"
     },
     {
-      "hash": "sha256-eIEyIDJ9wvjoKlHJYZqsK+XOpdBnqvXIHQfLE2kYUgg=",
+      "hash": "sha256-aBb3Ws6aKr8HoqdvMWhlFcTioAtGCuev1ciwVTsGvWI=",
       "url": "_content/MindExecution.Shared/js/mind-map-automation-edge-motion.js"
     },
+    {
+      "hash": "sha256-3Eq/7KjgDLLpaVaYN6QORrPEMEnSvAov7PpMsVC9r0A=",
+      "url": "_content/MindExecution.Shared/js/mind-map-automation-edge-routing.js"
+    },
     {
       "hash": "sha256-W/h4gC38IZn54pM6q++JJFSbDBLokscPLSNvh3xMFpw=",
       "url": "_content/MindExecution.Shared/js/mind-map-board-render-ownership.js"
@@ -102,7 +106,7 @@ self.assetsManifest = {
       "url": "_content/MindExecution.Shared/js/mind-map-css3d-hotpath.js"
     },
     {
-      "hash": "sha256-B6Xgsm8b4LyGyp2L+3DZB0fxa3ZqZ9iqp+8K/UcsoB8=",
+      "hash": "sha256-agt+cyYP3mh+j+38obj+qziQPfOltovg2kWJUndOJXI=",
       "url": "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
     },
     {
@@ -446,44 +450,44 @@ self.assetsManifest = {
       "url": "_framework/MimeMapping.og9ys58ylm.dll"
     },
     {
-      "hash": "sha256-o9dLvKGmstXiu50XUmRpwwsv/y81aA/NGRnKJy/1mks=",
-      "url": "_framework/MindExecution.Core.l639gk1bj0.dll"
+      "hash": "sha256-7XrZrL5PkRnemA1LjFguxgE7rqR8wOLZXdACUZG0MWg=",
+      "url": "_framework/MindExecution.Core.zs4n1f9hjc.dll"
     },
     {
-      "hash": "sha256-cWxc5rwjR4RYwAhGrlp5vxEiT7qneX2jrUTLWjL37CY=",
-      "url": "_framework/MindExecution.Kernel.dhkjql36qa.dll"
+      "hash": "sha256-uUzGo7hkUYV9pS1KkxLa5+9cFsVlHBGjV/9K0NYwl8Y=",
+      "url": "_framework/MindExecution.Kernel.l9idvg7mp7.dll"
     },
     {
-      "hash": "sha256-4C8f3TLtj/VLuY9CpNvtPkWw5VtZl5ZnDe+Xq4d9LTU=",
-      "url": "_framework/MindExecution.Plugins.Admin.sdnqjd3bhw.dll"
+      "hash": "sha256-cWsGhcCLF1k1nJxbJosjPxO4RwkkmEkW+SwPRqnIWhM=",
+      "url": "_framework/MindExecution.Plugins.Admin.l37qx5d8zi.dll"
     },
     {
-      "hash": "sha256-GdIOYT2OuYdKorFOcfSWztPr8NIXddBdSj2kDJGORQw=",
-      "url": "_framework/MindExecution.Plugins.Business.dntgcr4fyr.dll"
+      "hash": "sha256-x2oOQwLMyVaZxKffXxSG3RCoRjXlINsX90AHK9sLqQk=",
+      "url": "_framework/MindExecution.Plugins.Business.d7b282yazn.dll"
     },
     {
-      "hash": "sha256-SymfLnM0iJss9UJY7xGZXwfVzzl2NvfpKrrIVhmpW2I=",
-      "url": "_framework/MindExecution.Plugins.Concept.jiz294lahg.dll"
+      "hash": "sha256-3kSdSqvBJAqTuy//MpLkJbupPx0hTSS3nL7nmpvyZFs=",
+      "url": "_framework/MindExecution.Plugins.Concept.iw98n0qz5k.dll"
     },
     {
-      "hash": "sha256-fzKMUnP4AFBBYkFh1IuhGyl7KMMkmCGKqlnPu4QBWUs=",
-      "url": "_framework/MindExecution.Plugins.Directory.v0qvphgk63.dll"
+      "hash": "sha256-dB6SrNy6adA7R6ubKq0YDreLSzAA2ws0m13aFP/wWVc=",
+      "url": "_framework/MindExecution.Plugins.Directory.cqgn6pa8di.dll"
     },
     {
-      "hash": "sha256-ovRoi3461C9eaSGfnBsDjS4EZKOZVhw3fLC7RELZUPU=",
-      "url": "_framework/MindExecution.Plugins.PlanMaster.mvfl14g6r9.dll"
+      "hash": "sha256-Q9g9/Xs3dhJT+2RVAXb5ZoCT0ep5DeXYPy/8W5TWtvY=",
+      "url": "_framework/MindExecution.Plugins.PlanMaster.j8xoa8nl57.dll"
     },
     {
-      "hash": "sha256-Ii4ds8rpDHBAXVQKrb3AATbtF0MfTw51Iqu44nzVBx0=",
-      "url": "_framework/MindExecution.Plugins.YouTube.e5ui1py8ia.dll"
+      "hash": "sha256-z31H/4EKYUcn0Ev09Yd1r9F9j6NvemCmjQzZhVHuehY=",
+      "url": "_framework/MindExecution.Plugins.YouTube.zvpzk7om4z.dll"
     },
     {
-      "hash": "sha256-KOoTEe4T+zZNRFKjb8sO4/v/Q0X/ZQ8riPIs+8Nomak=",
-      "url": "_framework/MindExecution.Shared.4pev6youhl.dll"
+      "hash": "sha256-zG0OUiZmgQ3P0BbT/fTv5PLjerpbYsHPyYB4qYl7l00=",
+      "url": "_framework/MindExecution.Shared.ovot7q606x.dll"
     },
     {
-      "hash": "sha256-VblMDl0VAUvXDfnNtQPlWo00If/P1WCx7Bo7y2+prrQ=",
-      "url": "_framework/MindExecution.Web.vzu3nwlp2r.dll"
+      "hash": "sha256-V7qhdSCSM+AG31Pc8swykgZwg1EN4Agz4VA/kCma+98=",
+      "url": "_framework/MindExecution.Web.bzuaz35jv0.dll"
     },
     {
       "hash": "sha256-IsZJ91/OW+fHzNqIgEc7Y072ns8z9dGritiSyvR9Wgc=",
@@ -529,6 +533,10 @@ self.assetsManifest = {
       "hash": "sha256-Kon62RCQ4pqGTawYsp9LgAVwT/66ptahk8JIgsdBQvk=",
       "url": "_framework/Supabase.azmaw5pgcz.dll"
     },
+    {
+      "hash": "sha256-a103KEA3xZ0tBaSi99B7VXuEscpr6RMGe1/eFNuz670=",
+      "url": "_framework/System.Collections.3iuoxbe8my.dll"
+    },
     {
       "hash": "sha256-PytlRTU4Hx5iWOPXNkXYQIt24hVsUppWY5vgpx8PTIc=",
       "url": "_framework/System.Collections.Concurrent.vow3rm1dku.dll"
@@ -545,10 +553,6 @@ self.assetsManifest = {
       "hash": "sha256-opanE88Yp6SrsrXZ9LaqM1diY8Q0jMrG3jvYM8v3Rao=",
       "url": "_framework/System.Collections.Specialized.ugkjbs6p02.dll"
     },
-    {
-      "hash": "sha256-ZbcBWmgkYTGdeU2GzVkRs8SERVp8OCUrNQFKiPseGb0=",
-      "url": "_framework/System.Collections.zyvbaq6mpd.dll"
-    },
     {
       "hash": "sha256-ALmLuW4qrS6x9RlN/Gl2e3DeAW9Ms8T9YcuoATYejvc=",
       "url": "_framework/System.ComponentModel.Annotations.clwo0z2oyu.dll"
@@ -670,8 +674,8 @@ self.assetsManifest = {
       "url": "_framework/System.ObjectModel.yct1gdirzf.dll"
     },
     {
-      "hash": "sha256-dF/Q+yfJy5iZl9Auw+hkCG9FdPHTCzfL06D3ps9JZNw=",
-      "url": "_framework/System.Private.CoreLib.wflwsce1yq.dll"
+      "hash": "sha256-iSaryfzFI9zYnC5XopFpIBHr1sej8SGOWduSn1XMmvs=",
+      "url": "_framework/System.Private.CoreLib.7s8wte759y.dll"
     },
     {
       "hash": "sha256-MB8kD4MSWVtneMtZ06c8cKXJCO/EBXrSY3H535KTU9o=",
@@ -802,7 +806,7 @@ self.assetsManifest = {
       "url": "_framework/Websocket.Client.vapounvmnl.dll"
     },
     {
-      "hash": "sha256-00g6lZAcB0GYDBhxl4x36IRIi/jFnPu33Z7RB0uqomA=",
+      "hash": "sha256-PhUrI4I2+YbbML6TFXABhXBOVOkTCkSjSyLFEU3MV6w=",
       "url": "_framework/blazor.boot.json"
     },
     {
@@ -818,8 +822,8 @@ self.assetsManifest = {
       "url": "_framework/dotnet.native.566r55w3xu.js"
     },
     {
-      "hash": "sha256-JwqtZ6eQSm3ZoJ66YvMQloK1Oydj3T6smTFv8wLfh7g=",
-      "url": "_framework/dotnet.native.x6q5aixc38.wasm"
+      "hash": "sha256-VpLSM7+jVkgAxK0IdGVTMs1H8WAqeTX3Qqjhf85yP0s=",
+      "url": "_framework/dotnet.native.60hhmnxyoo.wasm"
     },
     {
       "hash": "sha256-vM4cfmuAtxs/dLoxiTCzPyPCyNkwOJu14cp6lXv3Sak=",
@@ -878,7 +882,7 @@ self.assetsManifest = {
       "url": "icon-512.png"
     },
     {
-      "hash": "sha256-XIPqZA6H2ppZ5Zp3LOjsqPkqGof0dFQG5DGQFMF2Bpg=",
+      "hash": "sha256-/4FO6qWSOiPW1lArHLy42ItKBPAa8YEu4eEs058CFJs=",
       "url": "index.html"
     },
     {

package/wwwroot/service-worker.js

@@ -1,4 +1,4 @@
-/* Manifest version: tcfcurmf */
+/* Manifest version: Xc2iV1/U */
 // Hosted deployments should prefer the network over stale offline caches.
 // This service worker immediately clears old Blazor offline caches and unregisters itself.