@mindexec/cli 0.2.481 → 0.2.483

package/electron/main.cjs

@@ -252,6 +252,8 @@ function sendUpdateStatus(status) {
   appendDesktopLog(
     `[update] state=${status.state} current=${status.currentVersion || ''} ` +
     `available=${status.availableVersion || ''} progress=${Math.round(status.progress || 0)} ` +
+    `bytes=${Math.round(status.downloadTransferredBytes || 0)}/${Math.round(status.downloadTotalBytes || 0)} ` +
+    `speed=${Math.round(status.downloadBytesPerSecond || 0)} ` +
     `kind=${status.installKind || ''}${status.error ? ` error=${status.error}` : ''}`
   );
   if (mainWindow && !mainWindow.isDestroyed() && !mainWindow.webContents.isDestroyed()) {

package/electron/source-smoke.mjs

@@ -34,6 +34,8 @@ assert.match(packageJson.scripts?.['desktop:publish:update:dev'] || '', /--chann
 assert.equal(packageJson.dependencies?.['electron-updater'], '^6.8.9', 'The packaged updater dependency is missing.');
 assert.equal(packageJson.build?.extraMetadata?.desktopUpdateChannel, 'dev', 'Development installers must stay on the dev feed.');
 assert.equal(packageJson.build?.publish?.provider, 'generic', 'Desktop updates must use the generic R2-backed provider.');
+assert.equal(packageJson.build?.publish?.useMultipleRangeRequest, false,
+  'Packaged differential downloads must use one byte range per request.');
 assert.equal(
   packageJson.build?.publish?.url,
   'https://mindexec.lovecrdm.workers.dev/dev/windows/x64',
@@ -98,6 +100,8 @@ assert.match(preloadSource, /mindExecDesktop/, 'The updater preload namespace ch
 assert.match(preloadSource, /updates:\s*\{/, 'The updater preload API is missing.');
 assert.match(updateManagerSource, /autoDownload\s*=\s*false/, 'Updates must not download through an unowned implicit path.');
 assert.match(updateManagerSource, /autoInstallOnAppQuit\s*=\s*false/, 'Updates must not restart without the explicit prompt path.');
+assert.match(updateManagerSource, /useMultipleRangeRequest:\s*false/,
+  'Differential downloads must use Worker-compatible single byte ranges.');
 assert.match(updateManagerSource, /quitAndInstall\(true, true\)/, 'Downloaded updates must relaunch silently after approval.');
 assert.match(updateManagerSource, /desktop-updates-require-installed-windows-app/,
   'Portable and unpacked builds must fail closed instead of replacing themselves.');

package/electron/update-manager-smoke.mjs

@@ -31,7 +31,12 @@ class FakeUpdater extends EventEmitter {
 
   async downloadUpdate() {
     this.downloadCalls += 1;
-    this.emit('download-progress', { percent: 42 });
+    this.emit('download-progress', {
+      percent: 42,
+      total: 2_737_300,
+      transferred: 1_149_666,
+      bytesPerSecond: 5_000_000
+    });
     await new Promise(resolve => setTimeout(resolve, 5));
     this.emit('update-downloaded', { version: '1.1.0' });
   }
@@ -79,7 +84,14 @@ test('concurrent checks share one version request and one download', async () =>
   assert.equal(second.state, 'downloaded');
   assert.equal(updater.checkCalls, 1);
   assert.equal(updater.downloadCalls, 1);
-  assert.deepEqual(updater.feed, { provider: 'generic', url: 'https://updates.example/dev/windows/x64' });
+  assert.deepEqual(updater.feed, {
+    provider: 'generic',
+    url: 'https://updates.example/dev/windows/x64',
+    useMultipleRangeRequest: false
+  });
+  assert.equal(first.downloadTotalBytes, 2_737_300);
+  assert.equal(first.downloadTransferredBytes, 1_149_666);
+  assert.equal(first.downloadBytesPerSecond, 5_000_000);
 });
 
 test('portable and unpacked executables never call electron-updater', async () => {

package/electron/update-manager.cjs

@@ -49,6 +49,9 @@ function createProductUpdateManager({
     availableVersion: '',
     downloaded: false,
     progress: 0,
+    downloadTotalBytes: 0,
+    downloadTransferredBytes: 0,
+    downloadBytesPerSecond: 0,
     error: '',
     configured: feed.configured,
     feedUrl: feed.url,
@@ -89,7 +92,13 @@ function createProductUpdateManager({
 
   updater.autoDownload = false;
   updater.autoInstallOnAppQuit = false;
-  if (feed.url) updater.setFeedURL({ provider: 'generic', url: feed.url });
+  if (feed.url) {
+    updater.setFeedURL({
+      provider: 'generic',
+      url: feed.url,
+      useMultipleRangeRequest: false
+    });
+  }
 
   updater.on('checking-for-update', () => {
     checkOutcome = 'checking';
@@ -102,15 +111,34 @@ function createProductUpdateManager({
       availableVersion: String(info?.version || ''),
       downloaded: false,
       progress: 0,
+      downloadTotalBytes: 0,
+      downloadTransferredBytes: 0,
+      downloadBytesPerSecond: 0,
       error: ''
     });
   });
   updater.on('update-not-available', () => {
     checkOutcome = 'current';
-    publish({ state: 'current', availableVersion: '', downloaded: false, progress: 0, error: '' });
+    publish({
+      state: 'current',
+      availableVersion: '',
+      downloaded: false,
+      progress: 0,
+      downloadTotalBytes: 0,
+      downloadTransferredBytes: 0,
+      downloadBytesPerSecond: 0,
+      error: ''
+    });
   });
   updater.on('download-progress', progress => {
-    publish({ state: 'downloading', progress: Number(progress?.percent || 0), error: '' });
+    publish({
+      state: 'downloading',
+      progress: Number(progress?.percent || 0),
+      downloadTotalBytes: Number(progress?.total || 0),
+      downloadTransferredBytes: Number(progress?.transferred || 0),
+      downloadBytesPerSecond: Number(progress?.bytesPerSecond || 0),
+      error: ''
+    });
   });
   updater.on('update-downloaded', info => {
     publish({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.481",
+  "version": "0.2.483",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -160,9 +160,10 @@
     "portable": {
       "artifactName": "MindExec-Portable-${version}-${arch}.${ext}"
     },
-    "publish": {
-      "provider": "generic",
-      "url": "https://mindexec.lovecrdm.workers.dev/dev/windows/x64"
-    }
+    "publish": {
+      "provider": "generic",
+      "url": "https://mindexec.lovecrdm.workers.dev/dev/windows/x64",
+      "useMultipleRangeRequest": false
+    }
   }
 }

package/scripts/desktop-update-publisher-smoke.mjs

@@ -54,6 +54,17 @@ test('publisher validates version, size, and SHA-512 before upload', async () =>
       }),
       /desktop-update-dev-unsigned-ack-required/
     );
+    assert.throws(
+      () => readReleasePlan({
+        platform: 'windows-x64',
+        directory,
+        packageVersion: '1.2.3',
+        channel: 'dev',
+        allowUnsigned: true
+      }),
+      /desktop-update-blockmap-missing/
+    );
+    await writeFile(join(directory, `${artifact}.blockmap`), Buffer.from('blockmap'));
     const plan = readReleasePlan({
       platform: 'windows-x64',
       directory,
@@ -62,7 +73,7 @@ test('publisher validates version, size, and SHA-512 before upload', async () =>
       allowUnsigned: true
     });
     assert.equal(plan.prefix, 'dev/windows/x64');
-    assert.deepEqual(plan.artifacts.map(item => item.fileName), [artifact]);
+    assert.deepEqual(plan.artifacts.map(item => item.fileName), [artifact, `${artifact}.blockmap`]);
     assert.throws(
       () => readReleasePlan({
         platform: 'windows-x64',

package/scripts/desktop-update-worker-smoke.mjs

@@ -70,3 +70,98 @@ test('worker preserves resumable byte-range responses for large installers', asy
   assert.equal(response.headers.get('content-range'), 'bytes 8-11/20');
   assert.equal(response.headers.get('content-length'), '4');
 });
+
+test('worker serves electron-updater multi-range requests as multipart without returning the full installer', async () => {
+  const source = new TextEncoder().encode('0123456789abcdefghij');
+  const calls = [];
+  const env = {
+    UPDATE_BUCKET: {
+      head: async () => ({
+        size: source.byteLength,
+        httpEtag: '"release-etag"',
+        writeHttpMetadata(headers) { headers.set('content-type', 'application/octet-stream'); }
+      }),
+      get: async (_key, options) => {
+        calls.push(options.range);
+        const { offset, length } = options.range;
+        const bytes = source.slice(offset, offset + length);
+        return {
+          body: new ReadableStream({ start(controller) { controller.enqueue(bytes); controller.close(); } }),
+          size: source.byteLength,
+          range: { offset, length },
+          httpEtag: '"release-etag"',
+          writeHttpMetadata(headers) { headers.set('content-type', 'application/octet-stream'); }
+        };
+      }
+    }
+  };
+
+  const response = await worker.fetch(new Request(
+    'https://updates.example/dev/windows/x64/MindExec-0.2.461-dev-x64.exe',
+    { headers: { range: 'bytes=0-3,10-13' } }
+  ), env);
+  const body = await response.text();
+
+  assert.equal(response.status, 206);
+  assert.match(response.headers.get('content-type') || '', /^multipart\/byteranges; boundary=/i);
+  assert.equal(response.headers.has('content-range'), false);
+  assert.deepEqual(calls, [{ offset: 0, length: 4 }, { offset: 10, length: 4 }]);
+  assert.match(body, /Content-Range: bytes 0-3\/20\r\n\r\n0123/);
+  assert.match(body, /Content-Range: bytes 10-13\/20\r\n\r\nabcd/);
+  assert.equal(new TextEncoder().encode(body).byteLength, Number(response.headers.get('content-length')));
+  assert.ok(Number(response.headers.get('content-length')) < source.byteLength * 20,
+    'multi-range response must contain only requested parts, not the full installer');
+});
+
+test('worker rejects oversized or overlapping multi-range requests before reading R2', async () => {
+  let getCount = 0;
+  const metadata = {
+    size: 100_000_000,
+    httpEtag: '"release-etag"',
+    writeHttpMetadata(headers) { headers.set('content-type', 'application/octet-stream'); }
+  };
+  const env = {
+    UPDATE_BUCKET: {
+      head: async () => metadata,
+      get: async () => { getCount += 1; return null; }
+    }
+  };
+
+  const oversized = await worker.fetch(new Request(
+    'https://updates.example/dev/windows/x64/MindExec-0.2.461-dev-x64.exe',
+    { headers: { range: 'bytes=0-33554431,33554432-67108864' } }
+  ), env);
+  assert.equal(oversized.status, 416);
+
+  const overlapping = await worker.fetch(new Request(
+    'https://updates.example/dev/windows/x64/MindExec-0.2.461-dev-x64.exe',
+    { headers: { range: 'bytes=0-10,10-20' } }
+  ), env);
+  assert.equal(overlapping.status, 416);
+  assert.equal(getCount, 0);
+});
+
+test('worker fails closed when R2 does not honor an explicit multipart range', async () => {
+  const source = new TextEncoder().encode('0123456789abcdefghij');
+  const metadata = {
+    size: source.byteLength,
+    httpEtag: '"release-etag"',
+    writeHttpMetadata(headers) { headers.set('content-type', 'application/octet-stream'); }
+  };
+  const env = {
+    UPDATE_BUCKET: {
+      head: async () => metadata,
+      get: async () => ({
+        ...metadata,
+        range: { offset: 0, length: source.byteLength },
+        body: new ReadableStream({ start(controller) { controller.enqueue(source); controller.close(); } })
+      })
+    }
+  };
+
+  const response = await worker.fetch(new Request(
+    'https://updates.example/dev/windows/x64/MindExec-0.2.461-dev-x64.exe',
+    { headers: { range: 'bytes=0-3,10-13' } }
+  ), env);
+  await assert.rejects(response.arrayBuffer(), /desktop-update-range-mismatch:0-3/);
+});

package/scripts/publish-mindexec-desktop-updates.mjs

@@ -100,6 +100,12 @@ export function readReleasePlan({
     if (sha512Base64(filePath) !== item.sha512) {
       throw new Error(`desktop-update-artifact-hash-mismatch:${item.name}`);
     }
+    if (/\.exe$/i.test(item.name)) {
+      const blockmapName = `${item.name}.blockmap`;
+      if (!existsSync(resolve(releaseDir, blockmapName))) {
+        throw new Error(`desktop-update-blockmap-missing:${blockmapName}`);
+      }
+    }
   }
 
   const artifacts = readdirSync(releaseDir)
@@ -164,15 +170,17 @@ async function verifyPublished(plan) {
     throw new Error('desktop-update-public-manifest-mismatch');
   }
 
-  for (const item of plan.manifest.files) {
-    const artifactResponse = await fetch(`${PUBLIC_BASE_URL}/${plan.prefix}/${encodeURIComponent(item.name)}`, {
+  for (const artifact of plan.artifacts) {
+    const artifactResponse = await fetch(`${PUBLIC_BASE_URL}/${plan.prefix}/${encodeURIComponent(artifact.fileName)}`, {
       method: 'HEAD',
       cache: 'no-store'
     });
-    if (!artifactResponse.ok) throw new Error(`desktop-update-public-artifact-http-${artifactResponse.status}:${item.name}`);
-    const expectedSize = item.size || statSync(resolve(plan.manifest.filePath, '..', item.name)).size;
+    if (!artifactResponse.ok) {
+      throw new Error(`desktop-update-public-artifact-http-${artifactResponse.status}:${artifact.fileName}`);
+    }
+    const expectedSize = statSync(artifact.filePath).size;
     if (Number(artifactResponse.headers.get('content-length') || 0) !== expectedSize) {
-      throw new Error(`desktop-update-public-artifact-size-mismatch:${item.name}`);
+      throw new Error(`desktop-update-public-artifact-size-mismatch:${artifact.fileName}`);
     }
   }
 }

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-mXWbB+r0wD5ixhld4+MKtYH4yPbQ7mRkmT7v8rgb2+E=",
+    "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.2r5s0vx16i.dll": "MindExecution.Core.dll",
-      "MindExecution.Kernel.8y4azlvjyi.dll": "MindExecution.Kernel.dll",
-      "MindExecution.Plugins.Admin.dtzk93cn6n.dll": "MindExecution.Plugins.Admin.dll",
-      "MindExecution.Plugins.Business.uyqiv67u0q.dll": "MindExecution.Plugins.Business.dll",
-      "MindExecution.Plugins.Concept.5w50lskzj6.dll": "MindExecution.Plugins.Concept.dll",
-      "MindExecution.Plugins.Directory.a8isl4htud.dll": "MindExecution.Plugins.Directory.dll",
-      "MindExecution.Plugins.PlanMaster.imbm6hfih7.dll": "MindExecution.Plugins.PlanMaster.dll",
-      "MindExecution.Plugins.YouTube.ua03os14kk.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.yxk1a55sjz.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.9bmh8f8s3k.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.2r5s0vx16i.dll": "sha256-Hji7EvwLtfgPOiDYgH4DHXZibPhbdWcYiGPG4NjYCWg=",
-      "MindExecution.Kernel.8y4azlvjyi.dll": "sha256-cKFcW5yNWguo2InCvgpimy5t/MhGZ2f5zITqvF99lvg=",
-      "MindExecution.Plugins.Business.uyqiv67u0q.dll": "sha256-BqDkv3XHSL10h0Lda9sJCj4NVrhijSowakl9dgGKCzk=",
-      "MindExecution.Plugins.Concept.5w50lskzj6.dll": "sha256-1UKv7Dxs0goKcQOkSsYBdhbE7Vp5Oy4YpqvXOtzEMHM=",
-      "MindExecution.Plugins.PlanMaster.imbm6hfih7.dll": "sha256-pgGCEAp8dmn511srw7KD/2fctoAJgnHAzcvGWbhoWG4=",
-      "MindExecution.Shared.yxk1a55sjz.dll": "sha256-Ru7/Qulj+40HqtPdqDs5O6dNvshmQ6JngyipwN4/dcs=",
-      "MindExecution.Web.9bmh8f8s3k.dll": "sha256-Na9Tbn6PRhJ3L72qs5aIn+/ahlhtzZIxWc7r8G/vAtk="
+      "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.dtzk93cn6n.dll": "sha256-UQfkrWbcBYN30pXQ3RWIZqQwygXIvaBBqc/H6hqiTyE=",
-      "MindExecution.Plugins.Directory.a8isl4htud.dll": "sha256-tp9XZ/Nxysn/xuTsD8lsKyJt++V8GjSkjsXm++ZxhVk=",
-      "MindExecution.Plugins.YouTube.ua03os14kk.dll": "sha256-Rjxv6t01L71frLHXiB3nNEeuVc9CK7OOYtF8UwUyhSI="
+      "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": "TXjYyM9d",
+  "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-Hji7EvwLtfgPOiDYgH4DHXZibPhbdWcYiGPG4NjYCWg=",
-      "url": "_framework/MindExecution.Core.2r5s0vx16i.dll"
+      "hash": "sha256-7XrZrL5PkRnemA1LjFguxgE7rqR8wOLZXdACUZG0MWg=",
+      "url": "_framework/MindExecution.Core.zs4n1f9hjc.dll"
     },
     {
-      "hash": "sha256-cKFcW5yNWguo2InCvgpimy5t/MhGZ2f5zITqvF99lvg=",
-      "url": "_framework/MindExecution.Kernel.8y4azlvjyi.dll"
+      "hash": "sha256-uUzGo7hkUYV9pS1KkxLa5+9cFsVlHBGjV/9K0NYwl8Y=",
+      "url": "_framework/MindExecution.Kernel.l9idvg7mp7.dll"
     },
     {
-      "hash": "sha256-UQfkrWbcBYN30pXQ3RWIZqQwygXIvaBBqc/H6hqiTyE=",
-      "url": "_framework/MindExecution.Plugins.Admin.dtzk93cn6n.dll"
+      "hash": "sha256-cWsGhcCLF1k1nJxbJosjPxO4RwkkmEkW+SwPRqnIWhM=",
+      "url": "_framework/MindExecution.Plugins.Admin.l37qx5d8zi.dll"
     },
     {
-      "hash": "sha256-BqDkv3XHSL10h0Lda9sJCj4NVrhijSowakl9dgGKCzk=",
-      "url": "_framework/MindExecution.Plugins.Business.uyqiv67u0q.dll"
+      "hash": "sha256-x2oOQwLMyVaZxKffXxSG3RCoRjXlINsX90AHK9sLqQk=",
+      "url": "_framework/MindExecution.Plugins.Business.d7b282yazn.dll"
     },
     {
-      "hash": "sha256-1UKv7Dxs0goKcQOkSsYBdhbE7Vp5Oy4YpqvXOtzEMHM=",
-      "url": "_framework/MindExecution.Plugins.Concept.5w50lskzj6.dll"
+      "hash": "sha256-3kSdSqvBJAqTuy//MpLkJbupPx0hTSS3nL7nmpvyZFs=",
+      "url": "_framework/MindExecution.Plugins.Concept.iw98n0qz5k.dll"
     },
     {
-      "hash": "sha256-tp9XZ/Nxysn/xuTsD8lsKyJt++V8GjSkjsXm++ZxhVk=",
-      "url": "_framework/MindExecution.Plugins.Directory.a8isl4htud.dll"
+      "hash": "sha256-dB6SrNy6adA7R6ubKq0YDreLSzAA2ws0m13aFP/wWVc=",
+      "url": "_framework/MindExecution.Plugins.Directory.cqgn6pa8di.dll"
     },
     {
-      "hash": "sha256-pgGCEAp8dmn511srw7KD/2fctoAJgnHAzcvGWbhoWG4=",
-      "url": "_framework/MindExecution.Plugins.PlanMaster.imbm6hfih7.dll"
+      "hash": "sha256-Q9g9/Xs3dhJT+2RVAXb5ZoCT0ep5DeXYPy/8W5TWtvY=",
+      "url": "_framework/MindExecution.Plugins.PlanMaster.j8xoa8nl57.dll"
     },
     {
-      "hash": "sha256-Rjxv6t01L71frLHXiB3nNEeuVc9CK7OOYtF8UwUyhSI=",
-      "url": "_framework/MindExecution.Plugins.YouTube.ua03os14kk.dll"
+      "hash": "sha256-z31H/4EKYUcn0Ev09Yd1r9F9j6NvemCmjQzZhVHuehY=",
+      "url": "_framework/MindExecution.Plugins.YouTube.zvpzk7om4z.dll"
     },
     {
-      "hash": "sha256-Ru7/Qulj+40HqtPdqDs5O6dNvshmQ6JngyipwN4/dcs=",
-      "url": "_framework/MindExecution.Shared.yxk1a55sjz.dll"
+      "hash": "sha256-zG0OUiZmgQ3P0BbT/fTv5PLjerpbYsHPyYB4qYl7l00=",
+      "url": "_framework/MindExecution.Shared.ovot7q606x.dll"
     },
     {
-      "hash": "sha256-Na9Tbn6PRhJ3L72qs5aIn+/ahlhtzZIxWc7r8G/vAtk=",
-      "url": "_framework/MindExecution.Web.9bmh8f8s3k.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-WvsgoQTqkn6gicUIMbadHK3hWH9MBshwEhAMOUntDlA=",
+      "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: TXjYyM9d */
+/* 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.