@domainlang/language 0.5.2 → 0.7.0

package/src/domain-lang-module.ts

@@ -11,6 +11,7 @@ import { DomainLangGeneratedModule, DomainLangGeneratedSharedModule } from './ge
 import { registerValidationChecks } from './validation/domain-lang-validator.js';
 import { QualifiedNameProvider } from './lsp/domain-lang-naming.js';
 import { DomainLangScopeComputation } from './lsp/domain-lang-scope.js';
+import { DomainLangScopeProvider } from './lsp/domain-lang-scope-provider.js';
 import { DomainLangFormatter } from './lsp/domain-lang-formatter.js';
 import { DomainLangHoverProvider } from './lsp/hover/domain-lang-hover.js';
 import { DomainLangCompletionProvider } from './lsp/domain-lang-completion.js';
@@ -18,6 +19,7 @@ import { DomainLangCodeActionProvider } from './lsp/domain-lang-code-actions.js'
 import { ImportResolver } from './services/import-resolver.js';
 import { WorkspaceManager } from './services/workspace-manager.js';
 import { DomainLangWorkspaceManager } from './lsp/domain-lang-workspace-manager.js';
+import { DomainLangIndexManager } from './lsp/domain-lang-index-manager.js';
 
 /**
  * Declaration of custom services - add your own service classes here.
@@ -46,7 +48,8 @@ export type DomainLangServices = LangiumServices & DomainLangAddedServices
 
 const DomainLangSharedModule: Module<LangiumSharedServices, PartialLangiumSharedServices> = {
     workspace: {
-        WorkspaceManager: (services: LangiumSharedServices) => new DomainLangWorkspaceManager(services)
+        WorkspaceManager: (services: LangiumSharedServices) => new DomainLangWorkspaceManager(services),
+        IndexManager: (services: LangiumSharedServices) => new DomainLangIndexManager(services)
     }
 };
 
@@ -62,6 +65,7 @@ export const DomainLangModule: Module<DomainLangServices, PartialLangiumServices
     },
     references: {
         ScopeComputation: (services) => new DomainLangScopeComputation(services),
+        ScopeProvider: (services) => new DomainLangScopeProvider(services),
         QualifiedNameProvider: () => new QualifiedNameProvider()
     },
     lsp: {
@@ -103,6 +107,7 @@ export function createDomainLangServices(context: DefaultSharedModuleContext): {
     );
     shared.ServiceRegistry.register(DomainLang);
     registerValidationChecks(DomainLang);
+    
     if (!context.connection) {
         // We don't run inside a language server
         // Therefore, initialize the configuration provider instantly

package/src/domain-lang.langium

@@ -64,9 +64,11 @@ Type:
  * Can be nested via `in` to show subdomain hierarchy.
  * The `type` property indicates strategic importance (Core, Supporting, Generic) per Bounded Context Canvas.
  * Body is optional - allows header-only Domain definitions.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#domains)
  */
 Domain:
-    (/** A Domain represents a sphere of knowledge, influence, or activity. In DDD, it is the subject area to which the user applies a program. Example: Sales, Shipping, Accounting. */ 'Domain' | 'dom') name=ID ('in' parent=[Domain:QualifiedName])?
+    ('Domain' | 'dom') name=ID ('in' parent=[Domain:QualifiedName])?
     ('{'
         (
             ('description' Assignment description=STRING) |
@@ -84,9 +86,11 @@ Domain:
  * The `classification` property indicates strategic importance per Bounded Context Canvas.
  * The `evolution` property indicates maturity stage per Wardley Maps/BC Canvas.
  * The `archetype` property indicates behavioral role per DDD archetypes (Gateway, Execution, etc).
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#bounded-contexts)
  */
 BoundedContext:
-    (/** A Bounded Context defines the boundary within which a particular domain model is defined and applicable. It is a central pattern in DDD for managing complexity. Example: SalesContext, SupportContext. */ 'BoundedContext' | 'bc') name=ID 
+    ('BoundedContext' | 'bc') name=ID 
     ('for' domain=[Domain:QualifiedName])?
     (
         ('as' classification+=[Classification:QualifiedName])?
@@ -101,7 +105,7 @@ BoundedContext:
             ('evolution' Assignment evolution=[Classification:QualifiedName]) |
             ('archetype' Assignment archetype=[Classification:QualifiedName]) |
             (('metadata' | 'meta') '{' (metadata+=MetadataEntry)* '}') |
-            (('relationships' | 'integrations') '{' 
+            (('relationships' | 'integrations') '{'
                 (relationships += Relationship ((",")? relationships += Relationship)*)*
             '}') |
             (('terminology' | 'glossary') '{' 
@@ -126,26 +130,32 @@ MetadataEntry:
 /**
  * Team - People responsible for a Bounded Context or Domain.
  * Represents organizational boundaries in DDD.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#teams)
  */
 Team:
-    (/** A Team represents the people responsible for a Bounded Context or Domain. */ 'Team') name=ID
+    'Team' name=ID
 ;
 
 /**
  * Classification - Reusable label for categorizing elements.
  * Examples: Core, Supporting, Generic, Strategic, Commodity, Architectural, Business, Technical.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#classifications)
  */
 Classification:
-    (/** A Classification is a reusable label for categorizing domains, contexts, patterns, and decisions (e.g., Core, Supporting, Generic, Architectural, Business, Technical). */ 'Classification') name=ID
+    'Classification' name=ID
 ;
 
 /**
  * Metadata - Defines a key that can be used in metadata blocks.
  * Examples: Language, Framework, Database, Repository.
  * Can be defined locally or imported from stdlib.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#metadata)
  */
 Metadata:
-    (/** A Metadata defines a key that can be used in metadata blocks. Examples: Language, Framework, Database, Repository. Can be defined locally or imported from stdlib. */ 'Metadata') name=ID
+    'Metadata' name=ID
 ;
 
 
@@ -164,9 +174,11 @@ ObjectMap:
 /**
  * Context Map - Visualizes relationships between Bounded Contexts.
  * Shows integration patterns and team interactions.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#context-maps)
  */
 ContextMap:
-    (/** A Context Map visualizes and documents the relationships between Bounded Contexts, including their integration patterns. */ 'ContextMap' | 'cmap') name=ID
+    ('ContextMap' | 'cmap') name=ID
     '{'
         ('contains' boundedContexts += [+BoundedContext:QualifiedName] ((",")? boundedContexts += [+BoundedContext:QualifiedName])*)*
         (relationships += Relationship ((",")? relationships += Relationship)*)*
@@ -176,9 +188,11 @@ ContextMap:
 /**
  * Domain Map - Visualizes relationships between Domains.
  * Shows high-level domain organization and subdomain structure.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#domain-maps)
  */
 DomainMap:
-    (/** A Domain Map visualizes and documents the relationships between Domains. */ 'DomainMap' | 'dmap') name=ID
+    ('DomainMap' | 'dmap') name=ID
     '{'
         ('contains' domains += [+Domain:QualifiedName] ((",")? domains += [+Domain:QualifiedName])*)*
     '}'
@@ -191,6 +205,8 @@ DomainMap:
 /**
  * Relationship - Connection between two Bounded Contexts.
  * Supports DDD integration patterns (ACL, OHS, PL, etc.) and relationship types.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#relationships)
  */
 Relationship:
     ('[' leftPatterns+=IntegrationPattern (',' leftPatterns+=IntegrationPattern)* ']')? 
@@ -252,6 +268,8 @@ RelationshipType returns string:
 /**
  * Domain Terminology - Ubiquitous language terms with definitions.
  * Supports synonyms and examples for richer glossaries.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#terminology)
  */
 DomainTerm:
     ('Term' | 'term') name=ID (Assignment meaning=STRING)?
@@ -262,6 +280,8 @@ DomainTerm:
 /**
  * Decisions, Policies, and Business Rules.
  * All types are interchangeable - use what reads best for your domain.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#decisions-policies-rules)
  */
 AbstractDecision: 
     Decision | 
@@ -270,19 +290,19 @@ AbstractDecision:
 ;
 
 Decision:
-    (/** A documented choice or rule that affects the model or process. */ 'Decision' | 'decision') 
+    ('Decision' | 'decision') 
     ('[' classification=[Classification:QualifiedName] ']')?
     name=ID Assignment value=STRING
 ;
 
 Policy:
-    (/** A business rule or guideline that governs behavior within a context. */ 'Policy' | 'policy') 
+    ('Policy' | 'policy') 
     ('[' classification=[Classification:QualifiedName] ']')?
     name=ID Assignment value=STRING
 ;
 
 BusinessRule:
-    (/** A business rule or guideline that governs behavior within a context. */ 'Rule' | 'rule') 
+    ('Rule' | 'rule') 
     ('[' classification=[Classification:QualifiedName] ']')?
     name=ID Assignment value=STRING
 ;
@@ -301,17 +321,21 @@ BusinessRule:
  * 
  * All resolution details (source, version, integrity) live in model.yaml manifest.
  * Named imports and inline integrity checks have been removed per PRS-010.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#imports)
  */
 ImportStatement:
-    /** Imports types or namespaces from another file or module, enabling reuse and modularity. */ ('Import' | 'import') uri=STRING ('as' alias=ID)?
+    ('Import' | 'import') uri=STRING ('as' alias=ID)?
 ;
 
 /**
  * Namespace Declaration - Hierarchical namespacing for organizing models.
  * Combines package modularity with group-style nesting.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#namespaces)
  */
 NamespaceDeclaration:
-    (/** Namespaces organize large models into hierarchical qualified names for symbol resolution. */ 'Namespace' | 'ns') name=QualifiedName '{'
+    ('Namespace' | 'ns') name=QualifiedName '{'
         (children+=StructureElement)*
     '}'
 ;

package/src/generated/ast.ts

@@ -101,6 +101,8 @@ export type DomainLangTokenNames = DomainLangTerminalNames | DomainLangKeywordNa
 /**
  * Decisions, Policies, and Business Rules.
  * All types are interchangeable - use what reads best for your domain.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#decisions-policies-rules)
  */
 export type AbstractDecision = BusinessRule | Decision | Policy;
 
@@ -129,6 +131,8 @@ export function isAssignment(item: unknown): item is Assignment {
  * The `classification` property indicates strategic importance per Bounded Context Canvas.
  * The `evolution` property indicates maturity stage per Wardley Maps/BC Canvas.
  * The `archetype` property indicates behavioral role per DDD archetypes (Gateway, Execution, etc).
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#bounded-contexts)
  */
 export interface BoundedContext extends langium.AstNode {
     readonly $container: Model | NamespaceDeclaration;
@@ -206,6 +210,8 @@ export function isBusinessRule(item: unknown): item is BusinessRule {
 /**
  * Classification - Reusable label for categorizing elements.
  * Examples: Core, Supporting, Generic, Strategic, Commodity, Architectural, Business, Technical.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#classifications)
  */
 export interface Classification extends langium.AstNode {
     readonly $container: Model | NamespaceDeclaration;
@@ -235,6 +241,8 @@ export function isContainer(item: unknown): item is Container {
 /**
  * Context Map - Visualizes relationships between Bounded Contexts.
  * Shows integration patterns and team interactions.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#context-maps)
  */
 export interface ContextMap extends langium.AstNode {
     readonly $container: Model | NamespaceDeclaration;
@@ -279,6 +287,8 @@ export function isDecision(item: unknown): item is Decision {
  * Can be nested via `in` to show subdomain hierarchy.
  * The `type` property indicates strategic importance (Core, Supporting, Generic) per Bounded Context Canvas.
  * Body is optional - allows header-only Domain definitions.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#domains)
  */
 export interface Domain extends langium.AstNode {
     readonly $container: Model | NamespaceDeclaration;
@@ -306,6 +316,8 @@ export function isDomain(item: unknown): item is Domain {
 /**
  * Domain Map - Visualizes relationships between Domains.
  * Shows high-level domain organization and subdomain structure.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#domain-maps)
  */
 export interface DomainMap extends langium.AstNode {
     readonly $container: Model | NamespaceDeclaration;
@@ -327,6 +339,8 @@ export function isDomainMap(item: unknown): item is DomainMap {
 /**
  * Domain Terminology - Ubiquitous language terms with definitions.
  * Supports synonyms and examples for richer glossaries.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#terminology)
  */
 export interface DomainTerm extends langium.AstNode {
     readonly $container: BoundedContext;
@@ -359,6 +373,8 @@ export function isDomainTerm(item: unknown): item is DomainTerm {
  * 
  * All resolution details (source, version, integrity) live in model.yaml manifest.
  * Named imports and inline integrity checks have been removed per PRS-010.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#imports)
  */
 export interface ImportStatement extends langium.AstNode {
     readonly $container: Model;
@@ -390,6 +406,8 @@ export function isIntegrationPattern(item: unknown): item is IntegrationPattern
  * Metadata - Defines a key that can be used in metadata blocks.
  * Examples: Language, Framework, Database, Repository.
  * Can be defined locally or imported from stdlib.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#metadata)
  */
 export interface Metadata extends langium.AstNode {
     readonly $container: Model | NamespaceDeclaration;
@@ -446,6 +464,8 @@ export function isModel(item: unknown): item is Model {
 /**
  * Namespace Declaration - Hierarchical namespacing for organizing models.
  * Combines package modularity with group-style nesting.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#namespaces)
  */
 export interface NamespaceDeclaration extends langium.AstNode {
     readonly $container: Model | NamespaceDeclaration;
@@ -508,6 +528,8 @@ export function isQualifiedName(item: unknown): item is QualifiedName {
 /**
  * Relationship - Connection between two Bounded Contexts.
  * Supports DDD integration patterns (ACL, OHS, PL, etc.) and relationship types.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#relationships)
  */
 export interface Relationship extends langium.AstNode {
     readonly $container: BoundedContext | ContextMap;
@@ -575,6 +597,8 @@ export function isStructureElement(item: unknown): item is StructureElement {
 /**
  * Team - People responsible for a Bounded Context or Domain.
  * Represents organizational boundaries in DDD.
+ * 
+ * [Read more on domainlang.net](https://domainlang.net/reference/language#teams)
  */
 export interface Team extends langium.AstNode {
     readonly $container: Model | NamespaceDeclaration;

package/src/generated/grammar.ts

@@ -144,8 +144,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Domain",
-                "$comment": "/** A Domain represents a sphere of knowledge, influence, or activity. In DDD, it is the subject area to which the user applies a program. Example: Sales, Shipping, Accounting. */"
+                "value": "Domain"
               },
               {
                 "$type": "Keyword",
@@ -312,7 +311,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Domain - A sphere of knowledge or activity in DDD.\\n * Can be nested via \`in\` to show subdomain hierarchy.\\n * The \`type\` property indicates strategic importance (Core, Supporting, Generic) per Bounded Context Canvas.\\n * Body is optional - allows header-only Domain definitions.\\n */"
+      "$comment": "/**\\n * Domain - A sphere of knowledge or activity in DDD.\\n * Can be nested via \`in\` to show subdomain hierarchy.\\n * The \`type\` property indicates strategic importance (Core, Supporting, Generic) per Bounded Context Canvas.\\n * Body is optional - allows header-only Domain definitions.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#domains)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -325,8 +324,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "BoundedContext",
-                "$comment": "/** A Bounded Context defines the boundary within which a particular domain model is defined and applicable. It is a central pattern in DDD for managing complexity. Example: SalesContext, SupportContext. */"
+                "value": "BoundedContext"
               },
               {
                 "$type": "Keyword",
@@ -879,7 +877,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Bounded Context - A boundary within which a domain model is defined.\\n * Central pattern in DDD for managing complexity and team boundaries.\\n * Belongs to exactly ONE domain (fundamental DDD principle).\\n * Body properties can appear in any order. Validation enforces at-most-once constraint.\\n * The \`classification\` property indicates strategic importance per Bounded Context Canvas.\\n * The \`evolution\` property indicates maturity stage per Wardley Maps/BC Canvas.\\n * The \`archetype\` property indicates behavioral role per DDD archetypes (Gateway, Execution, etc).\\n */"
+      "$comment": "/**\\n * Bounded Context - A boundary within which a domain model is defined.\\n * Central pattern in DDD for managing complexity and team boundaries.\\n * Belongs to exactly ONE domain (fundamental DDD principle).\\n * Body properties can appear in any order. Validation enforces at-most-once constraint.\\n * The \`classification\` property indicates strategic importance per Bounded Context Canvas.\\n * The \`evolution\` property indicates maturity stage per Wardley Maps/BC Canvas.\\n * The \`archetype\` property indicates behavioral role per DDD archetypes (Gateway, Execution, etc).\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#bounded-contexts)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -959,7 +957,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Team - People responsible for a Bounded Context or Domain.\\n * Represents organizational boundaries in DDD.\\n */"
+      "$comment": "/**\\n * Team - People responsible for a Bounded Context or Domain.\\n * Represents organizational boundaries in DDD.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#teams)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -988,7 +986,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Classification - Reusable label for categorizing elements.\\n * Examples: Core, Supporting, Generic, Strategic, Commodity, Architectural, Business, Technical.\\n */"
+      "$comment": "/**\\n * Classification - Reusable label for categorizing elements.\\n * Examples: Core, Supporting, Generic, Strategic, Commodity, Architectural, Business, Technical.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#classifications)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1017,7 +1015,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Metadata - Defines a key that can be used in metadata blocks.\\n * Examples: Language, Framework, Database, Repository.\\n * Can be defined locally or imported from stdlib.\\n */"
+      "$comment": "/**\\n * Metadata - Defines a key that can be used in metadata blocks.\\n * Examples: Language, Framework, Database, Repository.\\n * Can be defined locally or imported from stdlib.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#metadata)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1057,8 +1055,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "ContextMap",
-                "$comment": "/** A Context Map visualizes and documents the relationships between Bounded Contexts, including their integration patterns. */"
+                "value": "ContextMap"
               },
               {
                 "$type": "Keyword",
@@ -1193,7 +1190,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Context Map - Visualizes relationships between Bounded Contexts.\\n * Shows integration patterns and team interactions.\\n */"
+      "$comment": "/**\\n * Context Map - Visualizes relationships between Bounded Contexts.\\n * Shows integration patterns and team interactions.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#context-maps)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1206,8 +1203,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "DomainMap",
-                "$comment": "/** A Domain Map visualizes and documents the relationships between Domains. */"
+                "value": "DomainMap"
               },
               {
                 "$type": "Keyword",
@@ -1301,7 +1297,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Domain Map - Visualizes relationships between Domains.\\n * Shows high-level domain organization and subdomain structure.\\n */"
+      "$comment": "/**\\n * Domain Map - Visualizes relationships between Domains.\\n * Shows high-level domain organization and subdomain structure.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#domain-maps)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1471,7 +1467,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Relationship - Connection between two Bounded Contexts.\\n * Supports DDD integration patterns (ACL, OHS, PL, etc.) and relationship types.\\n */"
+      "$comment": "/**\\n * Relationship - Connection between two Bounded Contexts.\\n * Supports DDD integration patterns (ACL, OHS, PL, etc.) and relationship types.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#relationships)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1830,7 +1826,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Domain Terminology - Ubiquitous language terms with definitions.\\n * Supports synonyms and examples for richer glossaries.\\n */"
+      "$comment": "/**\\n * Domain Terminology - Ubiquitous language terms with definitions.\\n * Supports synonyms and examples for richer glossaries.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#terminology)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1864,7 +1860,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Decisions, Policies, and Business Rules.\\n * All types are interchangeable - use what reads best for your domain.\\n */"
+      "$comment": "/**\\n * Decisions, Policies, and Business Rules.\\n * All types are interchangeable - use what reads best for your domain.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#decisions-policies-rules)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -1877,8 +1873,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Decision",
-                "$comment": "/** A documented choice or rule that affects the model or process. */"
+                "value": "Decision"
               },
               {
                 "$type": "Keyword",
@@ -1968,8 +1963,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Policy",
-                "$comment": "/** A business rule or guideline that governs behavior within a context. */"
+                "value": "Policy"
               },
               {
                 "$type": "Keyword",
@@ -2059,8 +2053,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Rule",
-                "$comment": "/** A business rule or guideline that governs behavior within a context. */"
+                "value": "Rule"
               },
               {
                 "$type": "Keyword",
@@ -2156,8 +2149,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
                 "$type": "Keyword",
                 "value": "import"
               }
-            ],
-            "$comment": "/** Imports types or namespaces from another file or module, enabling reuse and modularity. */"
+            ]
           },
           {
             "$type": "Assignment",
@@ -2193,13 +2185,12 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             ],
             "cardinality": "?"
           }
-        ],
-        "$comment": "/** Imports types or namespaces from another file or module, enabling reuse and modularity. */"
+        ]
       },
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Import Statement - Manifest-centric import system per PRS-010.\\n * \\n * Simplified syntax where import statements use short specifiers:\\n *   - External dependencies (from manifest): import \\"core\\" as Core\\n *   - Local files: import \\"./shared/types.dlang\\"\\n *   - Workspace-relative: import \\"~/contexts/sales.dlang\\"\\n * \\n * All resolution details (source, version, integrity) live in model.yaml manifest.\\n * Named imports and inline integrity checks have been removed per PRS-010.\\n */"
+      "$comment": "/**\\n * Import Statement - Manifest-centric import system per PRS-010.\\n * \\n * Simplified syntax where import statements use short specifiers:\\n *   - External dependencies (from manifest): import \\"core\\" as Core\\n *   - Local files: import \\"./shared/types.dlang\\"\\n *   - Workspace-relative: import \\"~/contexts/sales.dlang\\"\\n * \\n * All resolution details (source, version, integrity) live in model.yaml manifest.\\n * Named imports and inline integrity checks have been removed per PRS-010.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#imports)\\n */"
     },
     {
       "$type": "ParserRule",
@@ -2212,8 +2203,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
             "elements": [
               {
                 "$type": "Keyword",
-                "value": "Namespace",
-                "$comment": "/** Namespaces organize large models into hierarchical qualified names for symbol resolution. */"
+                "value": "Namespace"
               },
               {
                 "$type": "Keyword",
@@ -2259,7 +2249,7 @@ export const DomainLangGrammar = (): Grammar => loadedDomainLangGrammar ?? (load
       "entry": false,
       "fragment": false,
       "parameters": [],
-      "$comment": "/**\\n * Namespace Declaration - Hierarchical namespacing for organizing models.\\n * Combines package modularity with group-style nesting.\\n */"
+      "$comment": "/**\\n * Namespace Declaration - Hierarchical namespacing for organizing models.\\n * Combines package modularity with group-style nesting.\\n * \\n * [Read more on domainlang.net](https://domainlang.net/reference/language#namespaces)\\n */"
     },
     {
       "$type": "ParserRule",

package/src/index.ts

@@ -9,16 +9,22 @@ export * from './ast-augmentation.js';
 // Export centralized types (canonical source for all service types)
 export * from './services/types.js';
 
-// Export services
+// Export services (read-only for LSP - no network operations)
 export * from './services/workspace-manager.js';
-export * from './services/dependency-resolver.js';
-export * from './services/dependency-analyzer.js';
-export * from './services/governance-validator.js';
 export * from './services/import-resolver.js';
 export * from './services/relationship-inference.js';
-export * from './services/git-url-resolver.js';
 export * from './services/performance-optimizer.js';
-export * from './services/semver.js';
+
+// Export shared utilities
+export * from './utils/manifest-utils.js';
+
+// Note: The following services have been moved to CLI package:
+// - git-url-resolver.ts → @domainlang/cli/services
+// - dependency-resolver.ts → @domainlang/cli/services
+// - dependency-analyzer.ts → @domainlang/cli/services
+// - governance-validator.ts → @domainlang/cli/services
+// - semver.ts → @domainlang/cli/services
 
 // Export LSP services
 export * from './lsp/manifest-diagnostics.js';
+export { DomainLangIndexManager } from './lsp/domain-lang-index-manager.js';

package/src/lsp/domain-lang-code-actions.ts

@@ -46,16 +46,21 @@ export class DomainLangCodeActionProvider implements CodeActionProvider {
         document: LangiumDocument, 
         params: CodeActionParams
     ): MaybePromise<Array<Command | CodeAction> | undefined> {
-        const result: CodeAction[] = [];
-        const acceptor = (ca: CodeAction | undefined): void => {
-            if (ca) result.push(ca);
-        };
+        try {
+            const result: CodeAction[] = [];
+            const acceptor = (ca: CodeAction | undefined): void => {
+                if (ca) result.push(ca);
+            };
 
-        for (const diagnostic of params.context.diagnostics) {
-            this.createCodeActions(diagnostic, document, acceptor);
-        }
+            for (const diagnostic of params.context.diagnostics) {
+                this.createCodeActions(diagnostic, document, acceptor);
+            }
 
-        return result.length > 0 ? result : undefined;
+            return result.length > 0 ? result : undefined;
+        } catch (error) {
+            console.error('Error in getCodeActions:', error);
+            return undefined;
+        }
     }
 
     /**