PLATFORM BUILDER COMPLETE SCHEMA

Ecosistema completo para organización y gestión de contenido con interfaces espaciales

Platform Builder - Complete Schema

Session 46 - Final Architecture Draft Date: January 15, 2026 Status: DRAFT - Awaiting approval before implementation

0. TOOL INVENTORY (Corrected Analysis)

0.1 Tools in Unified Builder

Panel ID	Tool Type	Component	Library	Purpose
`builder-ai`	`vibe-universe`	`VibeUniverseEmbeddableComponent`	`@libs-structural/vibe-universe`	AI platform generation via natural language
`builder-canvas`	`universe-canvas`	`UniverseCanvasEmbeddableComponent`	`@libs-space/universe-canvas`	Visual canvas view of modules/sections
`builder-structure`	`structure-view`	`StructureViewEmbeddableComponent`	`@libs-space/universe-canvas`	Galaxy-centric structure view
`builder-preview`	`live-preview`	`LivePreviewEmbeddableComponent`	`@libs-space/universe-canvas`	Runtime preview of deployed platform
`builder-architect`	`universe-explorer`	`UniverseExplorerEmbeddableComponent`	`@libs-space/universe-explorer`	Visual TREE editor for universe hierarchy
`builder-pages`	`page-builder`	`PageBuilderEmbeddableComponent`	`@libs-structural/page-builder`	Widget-based page content editor
`builder-logic`	`singularity`	`SingularityEmbeddableComponent`	`@libs-structural/singularity-lib`	Flow/logic builder

0.2 Standalone Complex Tool: modular-universe

Library: @libs-structural/modular-universe

NOT in unified-builder dock panels - separate standalone builder that can be embedded.

Components:

ModularUniverseBuilderComponent - Main orchestrator
CanvasRootComponent (from universe-canvas) - Visual canvas
TreeViewComponent (from universe-map) - Hierarchy view
SectionConfigPanelComponent - Section configuration
FlowComposerComponent (from singularity) - Logic flows
ModuleCreationWizardComponent (from modularity-lib) - Module creation

Features:

Grid/Flexbox canvas with sections
Drag-and-drop module placement
Section configuration panels
Module installation/merging services
Platform export (Flutter, Web)
Widget flow configuration

Potential Overlap Issues:

Uses CanvasRootComponent which is also used by universe-canvas
Has its own tree view separate from universe-explorer
Has flow composer separate from singularity

0.3 Tool Purpose Matrix

┌─────────────────────────────────────────────────────────────────────────────┐
│                         WHAT EACH TOOL EDITS                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  UNIVERSE HIERARCHY (structure[])                                            │
│  ├── vibe-universe        → GENERATES entire hierarchy via AI               │
│  ├── universe-explorer    → EDITS hierarchy visually (tree nodes)           │
│  └── structure-view       → VIEWS galaxy-centric structure                  │
│                                                                              │
│  VISUAL LAYOUT (sections, canvas)                                            │
│  ├── universe-canvas      → VIEWS/EDITS module canvas representation        │
│  └── modular-universe     → EDITS sections with Flexbox/Grid (COMPLEX)      │
│                                                                              │
│  PAGE CONTENT (widgets)                                                      │
│  └── page-builder         → EDITS page widgets, properties, responsive      │
│                                                                              │
│  LOGIC/FLOWS                                                                 │
│  └── singularity          → EDITS flow logic, actions, events               │
│                                                                              │
│  PREVIEW                                                                     │
│  └── live-preview         → RENDERS runtime preview                         │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

0.4 User's Concern: modular-universe Complexity

The user noted modular-universe is:

Complex and hard to manage
Potentially needs breaking down into smaller NX libraries
BUT should keep UI/UX and functionality (hierarchy, drag-drop)

Recommended Decomposition (future refactor):

modular-universe (current monolith)
    ↓ break into ↓
├── @libs-space/canvas-core         → Core canvas rendering
├── @libs-space/section-builder     → Section management
├── @libs-space/module-placement    → Drag-drop module placement
├── @libs-space/layout-engine       → Flexbox/Grid layout logic
└── @libs-structural/export-engine  → Flutter/Web export

1. THE BIG PICTURE

┌─────────────────────────────────────────────────────────────────────────────┐
│                           PLATFORM BUILDER FLOW                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│   USER INPUT          →     TOOLS           →    DATA MODEL    →   RUNTIME  │
│                                                                              │
│   "Build me a                                                                │
│    restaurant         →   Vibe Universe     →   UniversalModule  →  Angular │
│    management              (AI Generator)        JSON Tree           App    │
│    platform"                    │                    │                 │    │
│                                 ▼                    ▼                 ▼    │
│                          Universe Explorer    MongoDB Storage    Deployed   │
│                          (Visual Editor)      + Code Files       Platform   │
│                                 │                    │                      │
│                                 ▼                    ▼                      │
│                          Modular Universe     NX Libraries                  │
│                          (Page Builder)       + Components                  │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

2. DATA MODEL - The Source of Truth

2.1 MongoDB: Universe Document

{
  "_id": "universe_1768491285156_abc",
  "name": "Restaurant Manager Pro",
  "slug": "restaurant-manager-pro",
  "spaceId": "space_12345",
  "deploymentStatus": "draft",
  
  "structure": [
    {
      "moduleId": "universe-root-restaurant-1768491285156",
      "config": {
        "type": "universe-root",
        "name": "Restaurant Manager Pro",
        "layout": { "type": "template", "template": "dashboard" }
      },
      "children": [
        // ... galaxies, worlds, modules
      ]
    }
  ],
  
  "moduleTreeVersion": 1,
  "moduleSchemaVersion": "2026.01"
}

2.2 Structure Node Schema

interface UniverseStructureNode {
  moduleId: string;           // Unique ID for this placement
  moduleRef?: string;         // Reference to reusable code module (optional)
  config: StructureNodeConfig;
  children: UniverseStructureNode[];
}

interface StructureNodeConfig {
  // Identity
  name: string;
  type: CosmicModuleType;     // 'universe-root' | 'galaxy' | 'world' | 'page-module' | etc.
  
  // Routing
  route?: string;             // URL segment
  
  // Layout
  layoutSlot?: LayoutSlot;    // Where in parent's layout: 'header' | 'sidebar' | 'content'
  layout?: ModuleLayout;      // This node's layout template
  
  // Placement Behavior
  inheritToChildren?: boolean; // Default: true for navigation, false for content
  
  // Page Reference (for page-module type)
  pageId?: string;            // Links to space_pages collection
  
  // AI Metadata
  ai?: ModuleAIMetadata;
}

2.3 Complete Example: Restaurant Platform

{
  "structure": [
    {
      "moduleId": "universe-root-restaurant-123",
      "config": {
        "type": "universe-root",
        "name": "Restaurant Manager Pro",
        "layout": { "type": "template", "template": "dashboard" }
      },
      "children": [
        {
          "moduleId": "nav-global-header-123",
          "moduleRef": "header-navigation",
          "config": {
            "type": "navigation",
            "name": "Global Header",
            "layoutSlot": "header",
            "inheritToChildren": true
          },
          "children": []
        },
        {
          "moduleId": "galaxy-admin-123",
          "config": {
            "type": "galaxy",
            "name": "Admin Portal",
            "route": "/admin",
            "layout": { "type": "template", "template": "split-sidebar" }
          },
          "children": [
            {
              "moduleId": "nav-admin-sidebar-123",
              "moduleRef": "sidebar-navigation",
              "config": {
                "type": "navigation",
                "name": "Admin Sidebar",
                "layoutSlot": "sidebar",
                "inheritToChildren": true
              },
              "children": []
            },
            {
              "moduleId": "world-dashboard-123",
              "config": {
                "type": "world",
                "name": "Dashboard",
                "route": "/dashboard",
                "layoutSlot": "content"
              },
              "children": [
                {
                  "moduleId": "page-dashboard-main-123",
                  "moduleRef": "dashboard-analytics",
                  "config": {
                    "type": "page-module",
                    "name": "Dashboard Analytics",
                    "pageId": "page_dashboard_123"
                  },
                  "children": []
                }
              ]
            },
            {
              "moduleId": "world-menu-123",
              "config": {
                "type": "world",
                "name": "Menu Management",
                "route": "/menu",
                "layoutSlot": "content"
              },
              "children": [
                {
                  "moduleId": "page-menu-list-123",
                  "moduleRef": "menu-item-management",
                  "config": {
                    "type": "page-module",
                    "name": "Menu Items",
                    "pageId": "page_menu_list_123"
                  },
                  "children": []
                }
              ]
            }
          ]
        },
        {
          "moduleId": "galaxy-customer-123",
          "config": {
            "type": "galaxy",
            "name": "Customer App",
            "route": "/app",
            "layout": { "type": "template", "template": "header-content-footer" }
          },
          "children": [
            {
              "moduleId": "world-order-123",
              "config": {
                "type": "world",
                "name": "Order Food",
                "route": "/order"
              },
              "children": [
                {
                  "moduleId": "page-order-flow-123",
                  "moduleRef": "order-flow",
                  "config": {
                    "type": "page-module",
                    "name": "Order Flow",
                    "pageId": "page_order_123"
                  },
                  "children": []
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}

3. INHERITANCE BEHAVIOR

3.1 Default Inheritance Rules

Module Type	`inheritToChildren` Default	Rationale
`navigation`	`true`	Navigation should persist across children
`layout`	`true`	Layout frames wrap children
`widget` (overlay/modal)	`true`	Modals available everywhere
`page-module`	`false`	Page content is specific to that route
`feature`	`false`	Features are typically page-specific
`widget` (content)	`false`	Content widgets are page-specific

3.2 Visual: How Inheritance Works

universe-root
├── Global Header (inheritToChildren: true)     ← Shows on ALL pages
│
├── galaxy: Admin (/admin)
│   ├── Admin Sidebar (inheritToChildren: true) ← Shows on all Admin pages
│   │
│   ├── world: Dashboard (/admin/dashboard)
│   │   └── Dashboard Content                   ← Only on this page
│   │
│   └── world: Users (/admin/users)
│       └── Users Table                         ← Only on this page
│
└── galaxy: Customer (/app)
    ├── Customer Nav (inheritToChildren: true)  ← Shows on all Customer pages
    │
    └── world: Order (/app/order)
        └── Order Form                          ← Only on this page

What renders on /admin/users:

Global Header (from universe-root, inherited)
Admin Sidebar (from galaxy:Admin, inherited)
Users Table (from world:Users, direct)

What renders on /app/order:

Global Header (from universe-root, inherited)
Customer Nav (from galaxy:Customer, inherited)
Order Form (from world:Order, direct)

4. TOOL INTERPRETATION

4.1 Vibe Universe Generator (AI)

Input: Natural language prompt Output: Complete UniversalModule[] tree

User: "Build a restaurant management platform with menu management, 
       order tracking, and customer ordering app"

AI generates:
├── universe-root
│   ├── navigation (Global Header) - inheritToChildren: true
│   ├── galaxy (Admin Portal)
│   │   ├── navigation (Admin Sidebar) - inheritToChildren: true
│   │   ├── world (Dashboard)
│   │   ├── world (Menu Management)
│   │   └── world (Orders)
│   └── galaxy (Customer App)
│       ├── world (Browse Menu)
│       └── world (Place Order)

AI Responsibilities:

Analyze prompt to detect domain (restaurant, ecommerce, etc.)
Create appropriate galaxies (admin vs customer)
Place navigation modules with inheritToChildren: true
Create worlds with proper routes
Generate code modules via ModuleCodeGeneratorService

4.2 Universe Explorer (Visual Architect)

Purpose: Visual tree editor for the universe structure

What it displays:

┌─────────────────────────────────────────────────────┐
│  Universe Architect                                  │
├─────────────────────────────────────────────────────┤
│                                                      │
│  [☀️] Restaurant Manager Pro (universe-root)         │
│   │                                                  │
│   ├─[🧭] Global Header          [inherited ✓]       │
│   │                                                  │
│   ├─[🌌] Admin Portal (/admin)                      │
│   │  │                                               │
│   │  ├─[🧭] Admin Sidebar       [inherited ✓]       │
│   │  │                                               │
│   │  ├─[🌍] Dashboard                               │
│   │  │   └─[📄] Dashboard Page                      │
│   │  │                                               │
│   │  └─[🌍] Menu Management                         │
│   │      └─[📄] Menu Items Page                     │
│   │                                                  │
│   └─[🌌] Customer App (/app)                        │
│      │                                               │
│      └─[🌍] Order Food                              │
│          └─[📄] Order Flow Page                     │
│                                                      │
└─────────────────────────────────────────────────────┘

User Actions:

Drag/drop to rearrange
Click to select and edit config
Right-click → "Add Galaxy", "Add World", "Add Module"
Toggle inheritToChildren in properties panel
Visual indicator for inherited modules

4.3 Page Builder (Widget Editor) - `page-builder`

Library: @libs-structural/page-builder Purpose: Widget-based visual page editor for page-module content

What it edits: space_pages collection - widgets, layout, properties

┌─────────────────────────────────────────────────────┐
│  Page Builder: Menu Management Page                  │
├─────────────────────────────────────────────────────┤
│                                                      │
│  [TOOLBAR: Undo | Redo | Save | Breakpoints]        │
│                                                      │
│  ┌────────────┬─────────────────────────────────┐   │
│  │ WIDGET     │  CANVAS                          │   │
│  │ PALETTE    │  ┌───────────────────────────┐   │   │
│  │            │  │                           │   │   │
│  │ • Text     │  │  ┌───────┐  ┌──────────┐  │   │   │
│  │ • Image    │  │  │ Title │  │ Search   │  │   │   │
│  │ • Button   │  │  └───────┘  └──────────┘  │   │   │
│  │ • Card     │  │                           │   │   │
│  │ • Table    │  │  ┌───────────────────┐    │   │   │
│  │ • Form     │  │  │  Data Table       │    │   │   │
│  │ • Chart    │  │  │  (drag to resize) │    │   │   │
│  │            │  │  └───────────────────┘    │   │   │
│  └────────────┴──┴───────────────────────────┘   │   │
│                                                      │
│  [PROPERTIES PANEL: Selected widget config]         │
│                                                      │
└─────────────────────────────────────────────────────┘

Features:

Drag & drop widgets from palette
Responsive breakpoints (mobile, tablet, desktop, wide)
Widget move/resize with grid snapping
Properties panel for selected widget
Undo/Redo history
Real-time save to space_pages

Key Insight:

Page Builder edits the CONTENT of a page-module
The page-module's position in hierarchy (universe-explorer) determines WHERE it shows
Page Builder doesn't manage inheritance - that's Universe Explorer's job

4.4 Modular Universe (Section Canvas) - `modular-universe`

Library: @libs-structural/modular-universe Purpose: Section-based canvas with Flexbox/Grid layouts (COMPLEX TOOL)

NOT the same as Page Builder!

┌─────────────────────────────────────────────────────┐
│  Modular Universe Builder                            │
├─────────────────────────────────────────────────────┤
│                                                      │
│  ┌────────────┬─────────────────────────────────┐   │
│  │ SIDEBAR    │  CANVAS (Flexbox/Grid)          │   │
│  │            │                                  │   │
│  │ [Palette]  │  ┌───────────────────────────┐   │   │
│  │ • Modules  │  │ SECTION: Header           │   │   │
│  │ • Templates│  │ [Module: Navigation]      │   │   │
│  │            │  └───────────────────────────┘   │   │
│  │ [Structure]│                                  │   │
│  │ • Tree     │  ┌───────────┬───────────────┐   │   │
│  │            │  │ Sidebar   │ Content       │   │   │
│  │            │  │           │               │   │   │
│  │            │  │ [NavMod]  │ [DashMod]     │   │   │
│  │            │  └───────────┴───────────────┘   │   │
│  │            │                                  │   │
│  └────────────┴──────────────────────────────────┘   │
│                                                      │
│  [CONFIG PANEL: Section settings, Layout config]    │
│                                                      │
└─────────────────────────────────────────────────────┘

What it does:

Grid/Flexbox layout management (sections)
Module placement into sections
Section configuration (layout type, spacing)
Tree view of hierarchy
Module installation/merging
Platform export (Flutter, Web)
Flow composer integration

Complexity Concern (User noted):

Does many things at once
Overlaps with: universe-canvas, universe-explorer, singularity
Consider breaking into smaller focused libraries

CRITICAL FINDING:

modular-universe routes actually load UniverseCanvasBuilderComponent from universe-canvas
The REAL monolith is UniverseCanvasBuilderComponent at 5676 lines
modular-universe is essentially a routing wrapper

modular-universe (routes only)
    ↓ loads
universe-canvas
    └── UniverseCanvasBuilderComponent (5676 lines - THE MONOLITH)
        ├── Canvas rendering
        ├── Module palette
        ├── Config panel
        ├── Route tree management
        ├── Preview system
        ├── Deployment system
        └── AI integration

4.5 Structure View / Galaxy Canvas - `structure-view`

Library: @libs-space/universe-canvas Purpose: Galaxy-centric view of the universe structure

┌─────────────────────────────────────────────────────┐
│  Structure View: Admin Portal Galaxy                 │
├─────────────────────────────────────────────────────┤
│                                                      │
│              [Admin Galaxy]                          │
│                    │                                 │
│         ┌─────────┼─────────┬─────────┐             │
│         ▼         ▼         ▼         ▼             │
│    [Dashboard] [Menu]  [Orders] [Settings]          │
│         │                   │                        │
│         ▼                   ▼                        │
│    [page-mod]          [page-mod]                   │
│                                                      │
└─────────────────────────────────────────────────────┘

4.6 Live Preview - `live-preview`

Library: @libs-space/universe-canvas Purpose: Runtime preview of the deployed platform

Shows what the actual platform looks like with:

Rendered navigation (inherited modules visible)
Actual Angular routing working
Module components loaded and rendered
Responsive preview (device size simulation)

4.7 Singularity / Logic Builder - `singularity`

Library: @libs-structural/singularity-lib Purpose: Visual flow and logic builder

What it edits: Event flows, actions, automations

┌─────────────────────────────────────────────────────┐
│  Logic Builder: Order Submit Flow                    │
├─────────────────────────────────────────────────────┤
│                                                      │
│  [Trigger: Button Click]                            │
│         │                                            │
│         ▼                                            │
│  [Action: Validate Form]                            │
│         │                                            │
│    ┌────┴────┐                                      │
│    ▼         ▼                                      │
│ [Success] [Error]                                   │
│    │         │                                      │
│    ▼         ▼                                      │
│ [API Call] [Show Toast]                             │
│    │                                                 │
│    ▼                                                 │
│ [Navigate]                                          │
│                                                      │
└─────────────────────────────────────────────────────┘

5. CODE GENERATION

5.1 What Gets Generated

For each module with moduleRef, the system generates an NX library:

modules/business/
├── menu-item-management/
│   ├── src/
│   │   ├── lib/
│   │   │   ├── menu-item-management.component.ts
│   │   │   ├── menu-item-management.component.html
│   │   │   ├── menu-item-management.component.scss
│   │   │   ├── menu-item-management.service.ts
│   │   │   ├── menu-item-management.store.ts
│   │   │   └── menu-item-management.manifest.ts
│   │   └── index.ts
│   ├── project.json
│   └── tsconfig.json
├── order-flow/
│   └── ... (same structure)
└── dashboard-analytics/
    └── ... (same structure)

5.2 Module Manifest (Generated)

// menu-item-management.manifest.ts
export const menuItemManagementManifest: ModuleManifest = {
  id: 'menu-item-management',
  name: 'Menu Item Management',
  version: '1.0.0',
  category: 'commerce',
  
  // Component registration
  component: MenuItemManagementComponent,
  
  // Placement hints
  placement: {
    typicalPosition: 'content',
    allowedLevels: ['nested', 'leaf'],
    defaultInheritance: false,
    recommendedParents: ['galaxy', 'world'],
  },
  
  // Public actions (for flows/automation)
  publicActions: [
    { id: 'create-menu-item', name: 'Create Menu Item', ... },
    { id: 'update-menu-item', name: 'Update Menu Item', ... },
  ],
  
  // Embeddable components (for page builder)
  embeddableComponents: [
    { id: 'menu-item-card', name: 'Menu Item Card', category: 'widget' },
    { id: 'menu-item-table', name: 'Menu Items Table', category: 'data-display' },
  ],
  
  // AI metadata
  ai: {
    description: 'Manage restaurant menu items including prices, descriptions, and availability',
    keywords: ['menu', 'food', 'items', 'prices', 'restaurant'],
    capabilities: ['crud', 'filtering', 'bulk-actions'],
  }
};

5.3 Code Module vs Structure Node

Concept	Where Stored	Purpose
Structure Node	`universe.structure[]`	WHERE a module is placed in hierarchy
Code Module	`space_modules` collection + `/modules/business/`	WHAT the module does (code, manifest)
Page	`space_pages` collection	Visual content (widgets, layout)

A structure node REFERENCES a code module:

{
  "moduleId": "page-menu-list-123",      // Unique placement ID
  "moduleRef": "menu-item-management",    // Reference to code module
  "config": { ... }                       // Instance-specific config
}

6. RUNTIME RENDERING

6.1 Route Resolution

When user navigates to /admin/menu:

// 1. Router matches route
'/admin/menu' → galaxy:admin → world:menu

// 2. Collect modules to render
modulesToRender = [
  // From universe-root (inherited)
  { module: 'Global Header', slot: 'header' },
  
  // From galaxy:admin (inherited)
  { module: 'Admin Sidebar', slot: 'sidebar' },
  
  // From world:menu (direct)
  { module: 'Menu Items Page', slot: 'content' },
]

// 3. Apply layout template (from galaxy)
template: 'split-sidebar'
slots: ['sidebar', 'content']

// 4. Render
┌─────────────────────────────────────┐
│ Global Header                       │
├──────────┬──────────────────────────┤
│ Admin    │ Menu Items Page          │
│ Sidebar  │ (content from page)      │
└──────────┴──────────────────────────┘

6.2 Inheritance Collection Algorithm

function collectModulesToRender(targetNode: StructureNode): RenderModule[] {
  const modules: RenderModule[] = [];
  
  // Walk up from universe-root to target
  const path = getPathToNode(universeRoot, targetNode);
  
  for (const node of path) {
    // Add this node's direct children that have inheritToChildren: true
    for (const child of node.children) {
      if (child.config.inheritToChildren === true) {
        modules.push({
          module: child,
          slot: child.config.layoutSlot || 'content',
          inheritedFrom: node.moduleId,
        });
      }
    }
  }
  
  // Add target node's own content (not inherited)
  for (const child of targetNode.children) {
    if (!child.config.inheritToChildren) {
      modules.push({
        module: child,
        slot: child.config.layoutSlot || 'content',
        inheritedFrom: null, // Direct, not inherited
      });
    }
  }
  
  return modules;
}

6.3 Angular App Structure (Deployed)

// app.routes.ts (generated)
export const routes: Routes = [
  {
    path: '',
    component: UniverseShellComponent, // Applies universe-root layout
    children: [
      {
        path: 'admin',
        component: GalaxyShellComponent, // Applies galaxy layout
        data: { galaxyId: 'galaxy-admin-123' },
        children: [
          {
            path: 'dashboard',
            component: WorldRendererComponent,
            data: { worldId: 'world-dashboard-123' }
          },
          {
            path: 'menu',
            component: WorldRendererComponent,
            data: { worldId: 'world-menu-123' }
          }
        ]
      },
      {
        path: 'app',
        component: GalaxyShellComponent,
        data: { galaxyId: 'galaxy-customer-123' },
        children: [
          {
            path: 'order',
            component: WorldRendererComponent,
            data: { worldId: 'world-order-123' }
          }
        ]
      }
    ]
  }
];

// UniverseShellComponent
@Component({
  template: `
    <!-- Render inherited modules from universe-root -->
    @for (module of inheritedModules(); track module.moduleId) {
      <ng-container [ngComponentOutlet]="getComponent(module)" />
    }
    
    <!-- Child routes (galaxies) -->
    <router-outlet />
  `
})
export class UniverseShellComponent {
  inheritedModules = computed(() => 
    this.getInheritedModules('universe-root')
  );
}

// WorldRendererComponent
@Component({
  template: `
    <!-- Render page content (not inherited) -->
    @for (module of pageModules(); track module.moduleId) {
      <ng-container [ngComponentOutlet]="getComponent(module)" />
    }
  `
})
export class WorldRendererComponent {
  worldId = input.required<string>();
  
  pageModules = computed(() => 
    this.getDirectModules(this.worldId())
  );
}

7. COSMIC HIERARCHY (FINAL)

7.1 Types

export type CosmicModuleType =
  | 'universe-root'  // ONE per universe, the sun
  | 'galaxy'         // Major sections with their own routes
  | 'world'          // Pages within a galaxy
  | 'page-module'    // Actual page content (references pageId)
  | 'navigation'     // Nav components (typically inherited)
  | 'layout'         // Layout wrappers
  | 'feature'        // Feature modules with business logic
  | 'widget'         // UI widgets
  | 'custom';        // Custom types

7.2 Hierarchy Rules

export const COSMIC_HIERARCHY_RULES: Record<CosmicModuleType, CosmicModuleType[]> = {
  'universe-root': ['galaxy', 'navigation', 'layout', 'widget'],
  'galaxy':        ['world', 'navigation', 'layout', 'feature'],
  'world':         ['page-module', 'layout', 'widget', 'feature'],
  'page-module':   ['widget', 'feature'],
  'navigation':    ['navigation', 'widget'],
  'layout':        ['galaxy', 'world', 'page-module', 'navigation', 'widget', 'feature'],
  'feature':       ['widget'],
  'widget':        [],
  'custom':        ['widget', 'feature']
};

7.3 Visual Icons & Colors

Type	Icon	Color	User Label
`universe-root`	`fa-sun`	`#fbbf24` (gold)	Universe Core
`galaxy`	`fa-star`	`#8b5cf6` (purple)	Galaxy
`world`	`fa-earth-americas`	`#14b8a6` (teal)	World
`page-module`	`fa-file`	`#3b82f6` (blue)	Page
`navigation`	`fa-compass`	`#64748b` (slate)	Navigation
`layout`	`fa-table-cells`	`#6b7280` (gray)	Layout
`widget`	`fa-puzzle-piece`	`#6366f1` (indigo)	Widget
`feature`	`fa-bolt`	`#f59e0b` (amber)	Feature

8. WHAT NEEDS TO BE BUILT/FIXED

8.1 High Priority

Task	Status	Notes
Add `inheritToChildren` to `StructureNodeConfig`	TODO	Default: true for nav, false for content
Update `WorldRendererComponent` to collect inherited modules	TODO	Use algorithm from section 6.2
Remove duplicate `UniversalModule` interfaces	TODO	Keep only `core-models` version
Update Universe Explorer to show inheritance indicator	TODO	Badge: "inherited"
Add toggle in properties panel for inheritance	TODO	Checkbox: "Show on child pages"

8.2 Medium Priority

Task	Status	Notes
Update `vibe-coding-orchestrator` to set proper inheritance	TODO	Navigation: true, content: false
Update `PlacementConstraintsService` for inheritance	TODO	Validate inheritance makes sense
Add "Make Global" quick action in context menu	TODO	Move to universe-root

8.3 Documentation

Task	Status	Notes
Update THE-ONE-WAY.md	TODO	Add inheritance section
Delete FINAL-COSMIC-ARCHITECTURE.md	TODO	Superseded by this
Create AI training examples	TODO	With inheritance patterns

9. QUESTIONS/DECISIONS

Before implementation:

Inheritance on move: If user moves a module from world to galaxy, should inheritToChildren auto-set to true?
- Recommendation: Yes, with confirmation dialog
Visual feedback: How should inherited modules be displayed in page builder?
- Recommendation: Grayed out with "inherited" badge, not editable in that context
Override inheritance: Can a world "opt out" of an inherited module from galaxy?
- Recommendation: Yes, via excludeInherited: ['moduleId'] config (future feature)

10. APPROVAL CHECKLIST

Data model approved (section 2)
Inheritance behavior approved (section 3)
Tool interpretation approved (section 4)
Runtime rendering approved (section 6)
Ready to implement