diff --git a/apps/frontend/src/features/architecture/components/ArchWorkspace.tsx b/apps/frontend/src/features/architecture/components/ArchWorkspace.tsx
index a126f77..8ec68e5 100644
--- a/apps/frontend/src/features/architecture/components/ArchWorkspace.tsx
+++ b/apps/frontend/src/features/architecture/components/ArchWorkspace.tsx
@@ -57,36 +57,39 @@ function ArchWorkspaceInner({ model, source }: ArchWorkspaceInnerProps) {
     heatmapMode,
     bookmarkedNodes,
     hiddenNodes,
+    collapsedLayers,
     showAllNodes,
+    showAllLayers,
     isolatedSubtree,
     setIsolatedSubtree,
     openContextMenu,
     closeContextMenu,
   } = useArchitectureStore();
 
-  const { nodes: initialNodes, edges: initialEdges } = useMemo(
-    () => getLayoutedElements(model.nodes, model.edges, {
+  const layoutOptions = useMemo(() => ({
+      layers: model.detectedLayers,
       heatmapMode,
       bookmarks: bookmarkedNodes,
       hiddenNodes,
       isolatedSubtree,
-    }),
-    [model, heatmapMode, bookmarkedNodes, hiddenNodes, isolatedSubtree]
+      collapsedLayers,
+    }), [model.detectedLayers, heatmapMode, bookmarkedNodes, hiddenNodes, isolatedSubtree, collapsedLayers]);
+
+  const { nodes: initialNodes, edges: initialEdges } = useMemo(
+    () => getLayoutedElements(model.nodes, model.edges, layoutOptions),
+    [model.nodes, model.edges, layoutOptions]
   );
 
   const [nodes, setNodes, onNodesChange] = useNodesState(initialNodes);
   const [edges, setEdges, onEdgesChange] = useEdgesState(initialEdges);
 
   useEffect(() => {
-    const { nodes: newNodes, edges: newEdges } = getLayoutedElements(model.nodes, model.edges, {
-      heatmapMode,
-      bookmarks: bookmarkedNodes,
-      hiddenNodes,
-      isolatedSubtree,
-    });
+    const { nodes: newNodes, edges: newEdges } = getLayoutedElements(model.nodes, model.edges, layoutOptions);
     setNodes(newNodes);
     setEdges(newEdges);
-  }, [heatmapMode, bookmarkedNodes, hiddenNodes, isolatedSubtree, model, setNodes, setEdges]);
+    const frame = requestAnimationFrame(() => reactFlowInstance.fitView({ padding: 0.12, duration: 300 }));
+    return () => cancelAnimationFrame(frame);
+  }, [layoutOptions, model.nodes, model.edges, reactFlowInstance, setNodes, setEdges]);
 
   useEffect(() => {
     setNodes((nds) =>
@@ -192,13 +195,15 @@ function ArchWorkspaceInner({ model, source }: ArchWorkspaceInnerProps) {
     setIsolatedSubtree(null);
     showAllNodes();
     const { nodes: newNodes, edges: newEdges } = getLayoutedElements(model.nodes, model.edges, {
-      heatmapMode,
-      bookmarks: bookmarkedNodes,
+      ...layoutOptions,
+      hiddenNodes: new Set(),
+      collapsedLayers: new Set(),
     });
+    showAllLayers();
     setNodes(newNodes);
     setEdges(newEdges);
     setTimeout(() => reactFlowInstance.fitView({ padding: 0.2, duration: 300 }), 50);
-  }, [model, setNodes, setEdges, reactFlowInstance, heatmapMode, bookmarkedNodes, setIsolatedSubtree, showAllNodes]);
+  }, [model, setNodes, setEdges, reactFlowInstance, layoutOptions, setIsolatedSubtree, showAllNodes, showAllLayers]);
 
   const handleExportPng = useCallback(() => {
     const el = document.querySelector('.react-flow') as HTMLElement;
@@ -301,7 +306,7 @@ function ArchWorkspaceInner({ model, source }: ArchWorkspaceInnerProps) {
                   onPaneClick={handlePaneClick}
                   nodeTypes={nodeTypes}
                   fitView
-                  fitViewOptions={{ padding: 0.2 }}
+                  fitViewOptions={{ padding: 0.12 }}
                   minZoom={0.1}
                   maxZoom={3}
                   proOptions={{ hideAttribution: true }}
diff --git a/apps/frontend/src/features/architecture/components/ArchitectureNode.test.tsx b/apps/frontend/src/features/architecture/components/ArchitectureNode.test.tsx
new file mode 100644
index 0000000..5d95d98
--- /dev/null
+++ b/apps/frontend/src/features/architecture/components/ArchitectureNode.test.tsx
@@ -0,0 +1,33 @@
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import { ReactFlowProvider, type NodeProps } from '@xyflow/react';
+import type { ArchFlowNode } from './ArchitectureNode';
+import { ArchitectureNode } from './ArchitectureNode';
+
+describe('ArchitectureNode', () => {
+  it('keeps the name, type, layer, and relationship state visible', () => {
+    const props = {
+      id: 'module:orders',
+      type: 'architectureNode',
+      data: {
+        label: 'Orders',
+        nodeType: 'service',
+        layer: 'business-logic',
+        relationshipState: 'connected',
+        description: 'Coordinates order processing.',
+        filesCount: 3,
+        complexity: 'medium',
+      },
+    } as NodeProps<ArchFlowNode>;
+
+    render(
+      <ReactFlowProvider>
+        <ArchitectureNode {...props} />
+      </ReactFlowProvider>,
+    );
+
+    expect(screen.getByText('Orders')).toBeInTheDocument();
+    expect(screen.getByText('Service · Business Logic')).toBeInTheDocument();
+    expect(screen.getByText('Connected')).toBeInTheDocument();
+  });
+});
diff --git a/apps/frontend/src/features/architecture/components/ArchitectureNode.tsx b/apps/frontend/src/features/architecture/components/ArchitectureNode.tsx
index d125ed4..c7da009 100644
--- a/apps/frontend/src/features/architecture/components/ArchitectureNode.tsx
+++ b/apps/frontend/src/features/architecture/components/ArchitectureNode.tsx
@@ -6,7 +6,7 @@ import {
   ListTodo, Zap,
 } from 'lucide-react';
 import { cn } from '@/shared/utils/cn';
-import type { ArchNodeType } from '@/shared/types/architecture';
+import type { ArchNodeType, RelationshipState } from '@/shared/types/architecture';
 
 const nodeConfig: Record<ArchNodeType, { icon: typeof Monitor; color: string; bg: string }> = {
   frontend: { icon: Monitor, color: 'text-blue-400', bg: 'bg-blue-500/10 border-blue-500/30' },
@@ -31,6 +31,8 @@ const nodeConfig: Record<ArchNodeType, { icon: typeof Monitor; color: string; bg
 export interface ArchNodeData {
   label: string;
   nodeType: ArchNodeType;
+  layer: string;
+  relationshipState: RelationshipState;
   description: string;
   filesCount: number;
   complexity: 'low' | 'medium' | 'high';
@@ -43,6 +45,17 @@ export interface ArchNodeData {
 
 export type ArchFlowNode = Node<ArchNodeData, 'architectureNode'>;
 
+const relationshipStateConfig: Record<RelationshipState, { label: string; className: string }> = {
+  connected: { label: 'Connected', className: 'bg-success/10 text-success' },
+  'no-observed-relationships': { label: 'No observed', className: 'bg-warning/10 text-warning' },
+  unresolved: { label: 'Unresolved', className: 'bg-destructive/10 text-destructive' },
+  'not-extracted': { label: 'Not extracted', className: 'bg-muted text-muted-foreground' },
+};
+
+function formatLabel(value: string): string {
+  return value.replace(/[-_]/g, ' ').replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+
 export const ArchitectureNode = memo(({ data }: NodeProps<ArchFlowNode>) => {
   const config = nodeConfig[data.nodeType] || nodeConfig.utilities;
   const Icon = config.icon;
@@ -59,7 +72,7 @@ export const ArchitectureNode = memo(({ data }: NodeProps<ArchFlowNode>) => {
   return (
     <div
       className={cn(
-        'relative rounded-lg border px-4 py-3 min-w-[160px] max-w-[200px] shadow-sm transition-all duration-200',
+        'relative h-[104px] w-[220px] rounded-lg border px-4 py-3 shadow-sm transition-all duration-200',
         config.bg,
         data.isSelected && 'ring-2 ring-primary shadow-lg scale-105',
         data.isHighlighted && !data.isSelected && 'ring-1 ring-primary/50 shadow-md',
@@ -68,7 +81,7 @@ export const ArchitectureNode = memo(({ data }: NodeProps<ArchFlowNode>) => {
     >
       <Handle
         type="target"
-        position={Position.Top}
+        position={Position.Left}
         className="!w-2 !h-2 !bg-muted-foreground/50 !border-0"
       />
       <div className="flex items-start gap-2.5">
@@ -77,13 +90,16 @@ export const ArchitectureNode = memo(({ data }: NodeProps<ArchFlowNode>) => {
         </div>
         <div className="min-w-0 flex-1">
           <div className="flex items-center gap-1">
-            <p className="text-xs font-medium text-foreground truncate">{data.label}</p>
+            <p className="text-sm font-semibold text-foreground truncate">{data.label}</p>
             {data.isBookmarked && (
               <span className="text-amber-400 text-[10px]">*</span>
             )}
           </div>
+          <p className="text-2xs text-muted-foreground mt-0.5 truncate">
+            {formatLabel(data.nodeType)} · {formatLabel(data.layer)}
+          </p>
           <p className="text-2xs text-muted-foreground mt-0.5 line-clamp-1">{data.description}</p>
-          <div className="flex items-center gap-2 mt-1.5">
+          <div className="flex items-center gap-1.5 mt-1.5 flex-wrap">
             {data.filesCount > 0 && (
               <span className="text-2xs text-muted-foreground">{data.filesCount} files</span>
             )}
@@ -97,12 +113,15 @@ export const ArchitectureNode = memo(({ data }: NodeProps<ArchFlowNode>) => {
             >
               {data.complexity}
             </span>
+            <span className={cn('text-2xs px-1 py-0.5 rounded', relationshipStateConfig[data.relationshipState].className)}>
+              {relationshipStateConfig[data.relationshipState].label}
+            </span>
           </div>
         </div>
       </div>
       <Handle
         type="source"
-        position={Position.Bottom}
+        position={Position.Right}
         className="!w-2 !h-2 !bg-muted-foreground/50 !border-0"
       />
     </div>
diff --git a/apps/frontend/src/features/architecture/components/ModuleExplorer.tsx b/apps/frontend/src/features/architecture/components/ModuleExplorer.tsx
index 1998f66..4a22aa2 100644
--- a/apps/frontend/src/features/architecture/components/ModuleExplorer.tsx
+++ b/apps/frontend/src/features/architecture/components/ModuleExplorer.tsx
@@ -4,7 +4,16 @@ import { cn } from '@/shared/utils/cn';
 import { useArchitectureStore } from '../store';
 
 export function ModuleExplorer() {
-  const { model, expandedModules, toggleModule, selectedNodeId, setSelectedNodeId, setHighlightedNodeIds } = useArchitectureStore();
+  const {
+    model,
+    expandedModules,
+    toggleModule,
+    collapsedLayers,
+    toggleLayer,
+    selectedNodeId,
+    setSelectedNodeId,
+    setHighlightedNodeIds,
+  } = useArchitectureStore();
 
   if (!model) return null;
 
@@ -32,10 +41,18 @@ export function ModuleExplorer() {
           return (
             <div key={layer.id}>
               <button
-                onClick={() => toggleModule(layer.id)}
+                onClick={() => {
+                  toggleModule(layer.id);
+                  toggleLayer(layer.id);
+                }}
                 onMouseEnter={() => handleModuleHover(layer.nodes)}
                 onMouseLeave={handleModuleLeave}
-                className="w-full flex items-center gap-1.5 px-2 py-1.5 rounded-md text-left hover:bg-accent/50 transition-colors"
+                aria-expanded={isExpanded}
+                aria-pressed={!collapsedLayers.has(layer.id)}
+                className={cn(
+                  'w-full flex items-center gap-1.5 px-2 py-1.5 rounded-md text-left hover:bg-accent/50 transition-colors',
+                  collapsedLayers.has(layer.id) && 'opacity-70'
+                )}
               >
                 <ChevronRight
                   className={cn(
diff --git a/apps/frontend/src/features/architecture/layout.test.ts b/apps/frontend/src/features/architecture/layout.test.ts
new file mode 100644
index 0000000..1ca282a
--- /dev/null
+++ b/apps/frontend/src/features/architecture/layout.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+import { getLayoutedElements } from './layout';
+import type { ArchEdge, ArchLayer, ArchNode } from '@/shared/types/architecture';
+
+function node(id: string, layer: string, relationshipState: ArchNode['relationshipState'] = 'connected'): ArchNode {
+  return {
+    id,
+    name: id,
+    type: 'service',
+    description: `${id} description`,
+    responsibilities: [],
+    files: [`${id}.ts`],
+    dependencies: [],
+    dependents: [],
+    estimatedComplexity: 'low',
+    estimatedLines: 20,
+    tags: [layer],
+    layer,
+    relationshipState,
+  };
+}
+
+function edge(source: string, target: string): ArchEdge {
+  return {
+    id: `${source}->${target}`,
+    source,
+    target,
+    type: 'dependency',
+    predicate: 'depends_on',
+    truthClass: 'resolved',
+    evidence: [],
+  };
+}
+
+const layers: ArchLayer[] = [
+  { id: 'presentation', name: 'Presentation', order: 0, nodes: ['web'] },
+  { id: 'business-logic', name: 'Business Logic', order: 1, nodes: ['api', 'worker'] },
+  { id: 'infrastructure', name: 'Infrastructure', order: 2, nodes: ['db'] },
+];
+
+describe('getLayoutedElements', () => {
+  it('places disconnected nodes into readable left-to-right layer columns', () => {
+    const result = getLayoutedElements(
+      [node('web', 'presentation'), node('api', 'business-logic'), node('worker', 'business-logic'), node('db', 'infrastructure')],
+      [edge('web', 'api')],
+      { layers },
+    );
+
+    const byId = new Map(result.nodes.map((item) => [item.id, item]));
+    expect(byId.get('web')!.position.x).toBeLessThan(byId.get('api')!.position.x);
+    expect(byId.get('api')!.position.x).toBeLessThan(byId.get('db')!.position.x);
+    expect(byId.get('api')!.position.x).toBe(byId.get('worker')!.position.x);
+    expect(byId.get('api')!.position.y).not.toBe(byId.get('worker')!.position.y);
+  });
+
+  it('keeps node geometry non-overlapping and preserves only real edges', () => {
+    const result = getLayoutedElements(
+      [node('web', 'presentation'), node('api', 'business-logic'), node('db', 'infrastructure')],
+      [edge('web', 'api')],
+      { layers },
+    );
+
+    const positions = result.nodes.map((item) => item.position);
+    for (let left = 0; left < positions.length; left += 1) {
+      for (let right = left + 1; right < positions.length; right += 1) {
+        const sameColumn = positions[left].x === positions[right].x;
+        const sameRow = positions[left].y === positions[right].y;
+        expect(sameColumn && sameRow).toBe(false);
+      }
+    }
+    expect(result.edges.map((item) => item.id)).toEqual(['web->api']);
+  });
+
+  it('removes collapsed layers and their incident edges', () => {
+    const result = getLayoutedElements(
+      [node('web', 'presentation'), node('api', 'business-logic'), node('db', 'infrastructure')],
+      [edge('web', 'api'), edge('api', 'db')],
+      { layers, collapsedLayers: new Set(['business-logic']) },
+    );
+
+    expect(result.nodes.map((item) => item.id)).toEqual(['web', 'db']);
+    expect(result.edges).toEqual([]);
+  });
+});
diff --git a/apps/frontend/src/features/architecture/layout.ts b/apps/frontend/src/features/architecture/layout.ts
index 511b2bf..ece3494 100644
--- a/apps/frontend/src/features/architecture/layout.ts
+++ b/apps/frontend/src/features/architecture/layout.ts
@@ -1,10 +1,12 @@
 import { Graph, layout } from '@dagrejs/dagre';
 import type { Edge } from '@xyflow/react';
-import type { ArchNode, ArchEdge, HeatmapMode } from '@/shared/types/architecture';
+import type { ArchLayer, ArchNode, ArchEdge, HeatmapMode } from '@/shared/types/architecture';
 import type { ArchFlowNode } from './components/ArchitectureNode';
 
-const NODE_WIDTH = 180;
-const NODE_HEIGHT = 80;
+export const ARCH_NODE_WIDTH = 220;
+export const ARCH_NODE_HEIGHT = 104;
+const RANK_GAP = 140;
+const NODE_GAP = 60;
 
 export function getLayoutedElements(
   archNodes: ArchNode[],
@@ -15,15 +17,20 @@ export function getLayoutedElements(
     bookmarks?: Set<string>;
     hiddenNodes?: Set<string>;
     isolatedSubtree?: string | null;
+    layers?: ArchLayer[];
+    collapsedLayers?: Set<string>;
   }
 ): { nodes: ArchFlowNode[]; edges: Edge[] } {
-  const direction = options?.direction || 'TB';
+  const direction = options?.direction || 'LR';
   const heatmapMode = options?.heatmapMode || 'none';
   const bookmarks = options?.bookmarks || new Set();
   const hiddenNodes = options?.hiddenNodes || new Set();
   const isolatedSubtree = options?.isolatedSubtree || null;
+  const collapsedLayers = options?.collapsedLayers || new Set();
 
-  let filteredNodes = archNodes.filter((n) => !hiddenNodes.has(n.id));
+  let filteredNodes = archNodes.filter(
+    (node) => !hiddenNodes.has(node.id) && !collapsedLayers.has(node.layer)
+  );
   let filteredEdges = archEdges;
 
   if (isolatedSubtree) {
@@ -34,29 +41,35 @@ export function getLayoutedElements(
 
   const g = new Graph();
   g.setDefaultEdgeLabel(() => ({}));
-  g.setGraph({ rankdir: direction, ranksep: 80, nodesep: 40, marginx: 40, marginy: 40 });
+  g.setGraph({ rankdir: direction, ranksep: RANK_GAP, nodesep: NODE_GAP, marginx: 40, marginy: 40 });
 
   filteredNodes.forEach((node) => {
-    g.setNode(node.id, { width: NODE_WIDTH, height: NODE_HEIGHT });
+    g.setNode(node.id, { width: ARCH_NODE_WIDTH, height: ARCH_NODE_HEIGHT });
   });
 
+  const filteredNodeIds = new Set(filteredNodes.map((node) => node.id));
   filteredEdges.forEach((edge) => {
-    if (filteredNodes.some((n) => n.id === edge.source) && filteredNodes.some((n) => n.id === edge.target)) {
+    if (filteredNodeIds.has(edge.source) && filteredNodeIds.has(edge.target)) {
       g.setEdge(edge.source, edge.target);
     }
   });
 
   layout(g);
 
+  const orderedLayers = getOrderedLayers(filteredNodes, options?.layers);
+  const layerPositions = getLayerPositions(filteredNodes, orderedLayers, g, direction);
+
   const nodes: ArchFlowNode[] = filteredNodes.map((node) => {
-    const pos = g.node(node.id);
+    const pos = layerPositions.get(node.id) || g.node(node.id);
     return {
       id: node.id,
       type: 'architectureNode' as const,
-      position: { x: pos.x - NODE_WIDTH / 2, y: pos.y - NODE_HEIGHT / 2 },
+      position: { x: pos.x - ARCH_NODE_WIDTH / 2, y: pos.y - ARCH_NODE_HEIGHT / 2 },
       data: {
         label: node.name,
         nodeType: node.type,
+        layer: node.layer,
+        relationshipState: node.relationshipState,
         description: node.description,
         filesCount: node.files.length,
         complexity: node.estimatedComplexity,
@@ -69,7 +82,7 @@ export function getLayoutedElements(
   });
 
   const edges: Edge[] = filteredEdges
-    .filter((e) => filteredNodes.some((n) => n.id === e.source) && filteredNodes.some((n) => n.id === e.target))
+    .filter((e) => filteredNodeIds.has(e.source) && filteredNodeIds.has(e.target))
     .map((edge) => ({
       id: edge.id,
       source: edge.source,
@@ -86,6 +99,64 @@ export function getLayoutedElements(
   return { nodes, edges };
 }
 
+function getOrderedLayers(nodes: ArchNode[], layers?: ArchLayer[]): ArchLayer[] {
+  const visibleNodeIds = new Set(nodes.map((node) => node.id));
+  const knownLayers = new Map((layers || []).map((layer) => [layer.id, layer]));
+  const layerIds = new Set(nodes.map((node) => node.layer));
+
+  return [...layerIds]
+    .sort((left, right) => {
+      const leftOrder = knownLayers.get(left)?.order ?? Number.MAX_SAFE_INTEGER;
+      const rightOrder = knownLayers.get(right)?.order ?? Number.MAX_SAFE_INTEGER;
+      return leftOrder - rightOrder || left.localeCompare(right);
+    })
+    .map((id) => ({
+      id,
+      name: knownLayers.get(id)?.name || id.replace('-', ' ').replace(/\b\w/g, (letter) => letter.toUpperCase()),
+      order: knownLayers.get(id)?.order ?? Number.MAX_SAFE_INTEGER,
+      nodes: (knownLayers.get(id)?.nodes || nodes.filter((node) => node.layer === id).map((node) => node.id))
+        .filter((nodeId) => visibleNodeIds.has(nodeId)),
+    }));
+}
+
+function getLayerPositions(
+  nodes: ArchNode[],
+  layers: ArchLayer[],
+  graph: Graph,
+  direction: 'TB' | 'LR',
+): Map<string, { x: number; y: number }> {
+  const positions = new Map<string, { x: number; y: number }>();
+  const nodesById = new Map(nodes.map((node) => [node.id, node]));
+
+  layers.forEach((layer, layerIndex) => {
+    const layerNodes = layer.nodes
+      .map((nodeId) => nodesById.get(nodeId))
+      .filter((node): node is ArchNode => node !== undefined)
+      .sort((left, right) => {
+        const leftY = graph.node(left.id)?.y ?? 0;
+        const rightY = graph.node(right.id)?.y ?? 0;
+        return leftY - rightY || left.name.localeCompare(right.name) || left.id.localeCompare(right.id);
+      });
+
+    const offset = -((layerNodes.length - 1) * (ARCH_NODE_HEIGHT + NODE_GAP)) / 2;
+    layerNodes.forEach((node, nodeIndex) => {
+      if (direction === 'LR') {
+        positions.set(node.id, {
+          x: layerIndex * (ARCH_NODE_WIDTH + RANK_GAP) + ARCH_NODE_WIDTH / 2,
+          y: offset + nodeIndex * (ARCH_NODE_HEIGHT + NODE_GAP) + ARCH_NODE_HEIGHT / 2,
+        });
+      } else {
+        positions.set(node.id, {
+          x: offset + nodeIndex * (ARCH_NODE_WIDTH + NODE_GAP) + ARCH_NODE_WIDTH / 2,
+          y: layerIndex * (ARCH_NODE_HEIGHT + RANK_GAP) + ARCH_NODE_HEIGHT / 2,
+        });
+      }
+    });
+  });
+
+  return positions;
+}
+
 function getSubtreeIds(rootId: string, nodes: ArchNode[], edges: ArchEdge[]): Set<string> {
   const ids = new Set<string>([rootId]);
   const queue = [rootId];
diff --git a/apps/frontend/src/features/architecture/store.ts b/apps/frontend/src/features/architecture/store.ts
index c10d73d..e12b898 100644
--- a/apps/frontend/src/features/architecture/store.ts
+++ b/apps/frontend/src/features/architecture/store.ts
@@ -17,6 +17,9 @@ interface ArchitectureState {
 
   expandedModules: Set<string>;
   toggleModule: (id: string) => void;
+  collapsedLayers: Set<string>;
+  toggleLayer: (id: string) => void;
+  showAllLayers: () => void;
 
   showMiniMap: boolean;
   setShowMiniMap: (show: boolean) => void;
@@ -77,6 +80,16 @@ export const useArchitectureStore = create<ArchitectureState>((set) => ({
       return { expandedModules: next };
     }),
 
+  collapsedLayers: new Set(),
+  toggleLayer: (id) =>
+    set((state) => {
+      const next = new Set(state.collapsedLayers);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return { collapsedLayers: next };
+    }),
+  showAllLayers: () => set({ collapsedLayers: new Set() }),
+
   showMiniMap: true,
   setShowMiniMap: (show) => set({ showMiniMap: show }),