@domainlang/language 0.12.0 → 0.13.0

package/src/lsp/domain-lang-completion.ts

@@ -1193,11 +1193,20 @@ export class DomainLangCompletionProvider extends DefaultCompletionProvider {
         acceptor(context, {
             label: 'relationship (with patterns)',
             kind: CompletionItemKind.Snippet,
-            insertText: '[${1|OHS,PL,ACL,CF,P,SK|}] ${2:Context1} -> [${3|OHS,PL,ACL,CF,P,SK|}] ${4:Context2}',
+            insertText: '${1:Context1} [${2|OHS,PL,ACL,CF,S,BBoM|}] -> [${3|CF,ACL,C,BBoM|}] ${4:Context2}',
             insertTextFormat: InsertTextFormat.Snippet,
-            documentation: 'Add a relationship with integration patterns',
+            documentation: 'Add a directional relationship with side patterns',
             sortText: '1_relationship_patterns'
         });
+
+        acceptor(context, {
+            label: 'relationship (symmetric)',
+            kind: CompletionItemKind.Snippet,
+            insertText: '${1:Context1} [${2|SK,P,SW|}] ${3:Context2}',
+            insertTextFormat: InsertTextFormat.Snippet,
+            documentation: 'Add a symmetric relationship (Shared Kernel, Partnership, or Separate Ways)',
+            sortText: '1_relationship_symmetric'
+        });
     }
 
     /**
@@ -1230,32 +1239,50 @@ export class DomainLangCompletionProvider extends DefaultCompletionProvider {
         acceptor: CompletionAcceptor,
         context: CompletionContext
     ): void {
-        // Integration pattern completions
-        const patterns = [
-            { label: 'OHS (Open Host Service)', insertText: '[OHS]', doc: 'Open Host Service pattern' },
-            { label: 'PL (Published Language)', insertText: '[PL]', doc: 'Published Language pattern' },
-            { label: 'ACL (Anti-Corruption Layer)', insertText: '[ACL]', doc: 'Anti-Corruption Layer pattern' },
-            { label: 'CF (Conformist)', insertText: '[CF]', doc: 'Conformist pattern' },
-            { label: 'P (Partnership)', insertText: '[P]', doc: 'Partnership pattern' },
-            { label: 'SK (Shared Kernel)', insertText: '[SK]', doc: 'Shared Kernel pattern' }
+        // Side patterns (for directional relationships)
+        const sidePatterns = [
+            { label: 'OHS (Open Host Service)', insertText: '[OHS]', doc: 'Open Host Service — upstream side pattern' },
+            { label: 'PL (Published Language)', insertText: '[PL]', doc: 'Published Language — upstream side pattern' },
+            { label: 'CF (Conformist)', insertText: '[CF]', doc: 'Conformist — downstream side pattern' },
+            { label: 'ACL (Anti-Corruption Layer)', insertText: '[ACL]', doc: 'Anti-Corruption Layer — downstream side pattern' },
+            { label: 'S (Supplier)', insertText: '[S]', doc: 'Supplier — upstream side (Customer/Supplier)' },
+            { label: 'C (Customer)', insertText: '[C]', doc: 'Customer — downstream side (Customer/Supplier)' },
+            { label: 'BBoM (Big Ball of Mud)', insertText: '[BBoM]', doc: 'Big Ball of Mud — either side' },
+        ];
+
+        for (const pattern of sidePatterns) {
+            acceptor(context, {
+                label: pattern.label,
+                kind: CompletionItemKind.EnumMember,
+                insertText: pattern.insertText,
+                documentation: pattern.doc,
+                sortText: `0_side_${pattern.label}`
+            });
+        }
+
+        // Symmetric patterns (for symmetric relationships)
+        const symmetricPatterns = [
+            { label: 'SK (Shared Kernel)', insertText: '[SK]', doc: 'Shared Kernel — symmetric relationship' },
+            { label: 'P (Partnership)', insertText: '[P]', doc: 'Partnership — symmetric relationship' },
+            { label: 'SW (Separate Ways)', insertText: '[SW]', doc: 'Separate Ways — symmetric relationship' },
         ];
 
-        for (const pattern of patterns) {
+        for (const pattern of symmetricPatterns) {
             acceptor(context, {
                 label: pattern.label,
                 kind: CompletionItemKind.EnumMember,
                 insertText: pattern.insertText,
                 documentation: pattern.doc,
-                sortText: `0_${pattern.label}`
+                sortText: `0_sym_${pattern.label}`
             });
         }
 
-        // Relationship arrow completions
+        // Directional arrows
         const arrows = [
             { label: '->', doc: 'Upstream to downstream' },
             { label: '<-', doc: 'Downstream to upstream' },
-            { label: '<->', doc: 'Bidirectional/Partnership' },
-            { label: '><', doc: 'Separate Ways' }
+            { label: '<->', doc: 'Bidirectional with patterns' },
+            { label: '><', doc: 'Separate Ways (arrow form)' },
         ];
 
         for (const arrow of arrows) {

package/src/lsp/domain-lang-formatter.ts

@@ -34,6 +34,40 @@ export class DomainLangFormatter extends AbstractFormatter {
             if (ast.isDomainMap(node)) {
                 this.formatBlock(node);
             }
+
+            // Directional relationships: A [OHS, PL] -> [CF, ACL] B
+            if (ast.isDirectionalRelationship(node)) {
+                const formatter = this.getNodeFormatter(node);
+                // No space inside bracket groups
+                formatter.keywords('[').append(Formatting.noSpace());
+                formatter.keywords(']').prepend(Formatting.noSpace());
+                formatter.keywords(',').append(Formatting.oneSpace());
+                // Space after left context name (before [ or ->)
+                formatter.property('left').append(Formatting.oneSpace());
+                // Space before right context name (after ] or ->)
+                formatter.property('right').prepend(Formatting.oneSpace());
+                // Arrow gets explicit surrounding space only from bracket-less sides
+                // to avoid double-spacing when bracket groups are present
+                if (node.leftPatterns.length > 0) {
+                    formatter.property('arrow').prepend(Formatting.oneSpace());
+                }
+                if (node.rightPatterns.length > 0) {
+                    formatter.property('arrow').append(Formatting.oneSpace());
+                }
+            }
+
+            // Symmetric relationships: A [SK] B OR A >< B
+            if (ast.isSymmetricRelationship(node)) {
+                const formatter = this.getNodeFormatter(node);
+                if (node.arrow === '><') {
+                    formatter.property('arrow').surround(Formatting.oneSpace());
+                }
+                // [SK] form: space before [, no space inside brackets, space after ]
+                formatter.keywords('[').prepend(Formatting.oneSpace());
+                formatter.keywords('[').append(Formatting.noSpace());
+                formatter.keywords(']').prepend(Formatting.noSpace());
+                formatter.keywords(']').append(Formatting.oneSpace());
+            }
         } catch (error) {
             console.error('Error in format:', error);
             // Continue - don't crash formatting

package/src/lsp/domain-lang-index-manager.ts

@@ -1,7 +1,6 @@
 import type { LangiumDocument, LangiumSharedCoreServices, URI } from 'langium';
 import { DefaultIndexManager, DocumentState } from 'langium';
 import { CancellationToken } from 'vscode-jsonrpc';
-import { resolveImportPath } from '../utils/import-utils.js';
 import type { Model } from '../generated/ast.js';
 import type { ImportResolver } from '../services/import-resolver.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
@@ -96,7 +95,7 @@ export class DomainLangIndexManager extends DefaultIndexManager {
     /**
      * DI-injected import resolver. Set via late-binding because
      * IndexManager (shared module) is created before ImportResolver (language module).
-     * Falls back to standalone resolveImportPath when not set.
+     * Always set before any document indexing begins via `setLanguageServices()`.
      */
     private importResolver: ImportResolver | undefined;
 
@@ -117,15 +116,13 @@ export class DomainLangIndexManager extends DefaultIndexManager {
     }
 
     /**
-     * Resolves an import path using the DI-injected ImportResolver when available,
-     * falling back to the standalone resolver for backwards compatibility.
+     * Resolves an import path using the DI-injected ImportResolver.
      */
-    private async resolveImport(document: LangiumDocument, specifier: string): Promise<URI> {
-        if (this.importResolver) {
-            return this.importResolver.resolveForDocument(document, specifier);
+    private resolveImport(document: LangiumDocument, specifier: string): Promise<URI> {
+        if (!this.importResolver) {
+            throw new Error('ImportResolver not initialised — ensure setLanguageServices() was called');
         }
-        // Fallback for contexts where language services aren't wired (e.g., tests)
-        return resolveImportPath(document, specifier);
+        return this.importResolver.resolveForDocument(document, specifier);
     }
 
     /**

package/src/lsp/domain-lang-workspace-manager.ts

@@ -66,7 +66,7 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
     /**
      * DI-injected import resolver. Set via late-binding because
      * WorkspaceManager (shared module) is created before ImportResolver (language module).
-     * Falls back to standalone ensureImportGraphFromDocument when not set.
+     * Always set before any workspace loading begins via `setLanguageServices()`.
      */
     private importResolver: ImportResolver | undefined;
 
@@ -296,35 +296,9 @@ export class DomainLangWorkspaceManager extends DefaultWorkspaceManager {
      */
     private async loadImportGraph(document: LangiumDocument): Promise<Set<string>> {
         if (!this.importResolver) {
-            // Fallback to standalone utility when DI isn't wired
-            return ensureImportGraphFromDocument(document, this.langiumDocuments);
+            throw new Error('ImportResolver not initialised — ensure setLanguageServices() was called');
         }
-
-        const resolver = this.importResolver;
-        const langiumDocuments = this.langiumDocuments;
-        const visited = new Set<string>();
-
-        async function visit(doc: LangiumDocument): Promise<void> {
-            const uriString = doc.uri.toString();
-            if (visited.has(uriString)) return;
-            visited.add(uriString);
-
-            const model = doc.parseResult.value as { imports?: Array<{ uri?: string }> };
-            for (const imp of model.imports ?? []) {
-                if (!imp.uri) continue;
-
-                try {
-                    const resolvedUri = await resolver.resolveForDocument(doc, imp.uri);
-                    const childDoc = await langiumDocuments.getOrCreateDocument(resolvedUri);
-                    await visit(childDoc);
-                } catch {
-                    // Import resolution failed — validation will report the error
-                }
-            }
-        }
-
-        await visit(document);
-        return visited;
+        return ensureImportGraphFromDocument(document, this.langiumDocuments, this.importResolver);
     }
 
     // --- PRS-017 R7: Progress reporting ---

package/src/lsp/explain.ts

@@ -22,9 +22,11 @@ import {
     isBoundedContext,
     isClassification,
     isContextMap,
+    isDirectionalRelationship,
     isDomain,
     isDomainMap,
     isRelationship,
+    isSymmetricRelationship,
     isTeam,
 } from '../generated/ast.js';
 import {
@@ -133,9 +135,15 @@ function explainClassification(classification: Classification): string {
 function explainRelationship(relationship: Relationship): string {
     const leftName = relationship.left.link?.ref?.name ?? 'unknown';
     const rightName = relationship.right.link?.ref?.name ?? 'unknown';
-    const arrow = relationship.arrow;
 
-    const description = `Relationship from **${leftName}** ${arrow} **${rightName}**`;
+    let relationText = '↔';
+    if (isDirectionalRelationship(relationship)) {
+        relationText = relationship.arrow;
+    } else if (isSymmetricRelationship(relationship)) {
+        relationText = relationship.pattern ? `[${relationship.pattern.$type}]` : '><';
+    }
+
+    const description = `Relationship from **${leftName}** ${relationText} **${rightName}**`;
     return formatHoverContent('', '🔗', 'relationship', undefined, [description]);
 }
 

package/src/lsp/hover/domain-lang-hover.ts

@@ -385,14 +385,17 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
     private getRelationshipHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isRelationship(node)) return undefined;
 
-        const leftPatterns = node.leftPatterns.join(', ');
-        const rightPatterns = node.rightPatterns.join(', ');
         const fields: string[] = [
-            `${this.refLink(node.left.link)} ${node.arrow} ${this.refLink(node.right.link)}`
+            `${this.refLink(node.left.link)} ${node.arrow ?? '↔'} ${this.refLink(node.right.link)}`
         ];
-        if (node.type) fields.push(`**Type:** \`${node.type}\``);
-        if (leftPatterns) fields.push(`**Left patterns:** ${leftPatterns}`);
-        if (rightPatterns) fields.push(`**Right patterns:** ${rightPatterns}`);
+        if (ast.isDirectionalRelationship(node)) {
+            const leftPatterns = node.leftPatterns.map(p => p.$type).join(', ');
+            const rightPatterns = node.rightPatterns.map(p => p.$type).join(', ');
+            if (leftPatterns) fields.push(`**Left patterns:** ${leftPatterns}`);
+            if (rightPatterns) fields.push(`**Right patterns:** ${rightPatterns}`);
+        } else if (ast.isSymmetricRelationship(node) && node.pattern) {
+            fields.push(`**Pattern:** ${node.pattern.$type}`);
+        }
 
         return this.formatHover(commentBlock, '🔗', 'relationship', undefined, fields);
     }
@@ -439,8 +442,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
     private formatRelationshipLine(rel: ast.Relationship): string {
         const left = this.refLink(rel.left?.link);
         const right = this.refLink(rel.right?.link);
-        const type = rel.type ? ` \`${rel.type}\`` : '';
-        return `- ${left} ${rel.arrow} ${right}${type}`;
+        return `- ${left} ${rel.arrow ?? '↔'} ${right}`;
     }
 
     /**

package/src/lsp/hover/domain-lang-keywords.ts

@@ -102,35 +102,38 @@ export const keywordExplanations: Record<string, string> = {
     this: `**this** - References the current bounded context in relationships.${REL_LINK}`,
 
     // ========================================================================
-    // DDD Integration Patterns
-    // ========================================================================
-    acl: `**ACL** - Anti-Corruption Layer. Protects from external models by translating between domains.${REL_LINK}`,
-    anticorruptionlayer: `**AntiCorruptionLayer** - Protects from external models by translating between domains.${REL_LINK}`,
-    ohs: `**OHS** - Open Host Service. Provides a well-documented API for integration.${REL_LINK}`,
-    openhostservice: `**OpenHostService** - Provides a well-documented API for integration.${REL_LINK}`,
-    pl: `**PL** - Published Language. Documented language for inter-context communication.${REL_LINK}`,
-    publishedlanguage: `**PublishedLanguage** - Documented language for inter-context communication.${REL_LINK}`,
-    cf: `**CF** - Conformist. Adopts upstream model without translation.${REL_LINK}`,
-    conformist: `**Conformist** - Adopts upstream model without translation.${REL_LINK}`,
-    p: `**P** - Partnership. Two teams with mutual dependency and shared goals.${REL_LINK}`,
-    partnership: `**Partnership** - Two teams with mutual dependency and shared goals.${REL_LINK}`,
-    sk: `**SK** - Shared Kernel. Shared code/data requiring careful coordination.${REL_LINK}`,
-    sharedkernel: `**SharedKernel** - Shared code/data requiring careful coordination.${REL_LINK}`,
-    bbom: `**BBoM** - Big Ball of Mud. Legacy area without clear boundaries.${REL_LINK}`,
-    bigballofmud: `**BigBallOfMud** - Legacy area without clear boundaries.${REL_LINK}`,
+    // DDD Side Patterns (directional relationships)
+    // ========================================================================
+    acl: `**ACL** - Anti-Corruption Layer. Protects from external models by translating between domains. Used on the downstream side.${REL_LINK}`,
+    anticorruptionlayer: `**AntiCorruptionLayer** - Anti-Corruption Layer. Protects from external models by translating between domains. Used on the downstream side.${REL_LINK}`,
+    ohs: `**OHS** - Open Host Service. Provides a well-documented API for integration. Used on the upstream side.${REL_LINK}`,
+    openhostservice: `**OpenHostService** - Open Host Service. Provides a well-documented API for integration. Used on the upstream side.${REL_LINK}`,
+    pl: `**PL** - Published Language. Documented language for inter-context communication. Used on the upstream side.${REL_LINK}`,
+    publishedlanguage: `**PublishedLanguage** - Published Language. Documented language for inter-context communication. Used on the upstream side.${REL_LINK}`,
+    cf: `**CF** - Conformist. Adopts upstream model without translation. Used on the downstream side.${REL_LINK}`,
+    conformist: `**Conformist** - Conformist. Adopts upstream model without translation. Used on the downstream side.${REL_LINK}`,
+    s: `**S** - Supplier. Negotiated contract provider in a Customer/Supplier relationship. Must be on the upstream side.${REL_LINK}`,
+    supplier: `**Supplier** - Negotiated contract provider in a Customer/Supplier relationship. Must be on the upstream side.${REL_LINK}`,
+    c: `**C** - Customer. Negotiated contract consumer in a Customer/Supplier relationship. Must be on the downstream side.${REL_LINK}`,
+    customer: `**Customer** - Negotiated contract consumer in a Customer/Supplier relationship. Must be on the downstream side.${REL_LINK}`,
+    bbom: `**BBoM** - Big Ball of Mud. Legacy area without clear boundaries. Can appear on either side.${REL_LINK}`,
+    bigballofmud: `**BigBallOfMud** - Big Ball of Mud. Legacy area without clear boundaries. Can appear on either side.${REL_LINK}`,
 
     // ========================================================================
-    // Relationship Types
+    // DDD Symmetric Patterns (symmetric relationships — entity [Pattern] entity)
     // ========================================================================
-    customersupplier: `**CustomerSupplier** - Downstream depends on upstream with influence over priorities.${REL_LINK}`,
-    upstreamdownstream: `**UpstreamDownstream** - One context depends on another's model.${REL_LINK}`,
-    separateways: `**SeparateWays** - Contexts with no integration, solving problems independently.${REL_LINK}`,
+    p: `**P** - Partnership. Symmetric relationship: two teams with mutual dependency and shared goals. Usage: \`A [P] B\`${REL_LINK}`,
+    partnership: `**Partnership** - Symmetric relationship: two teams with mutual dependency and shared goals. Usage: \`A [Partnership] B\`${REL_LINK}`,
+    sk: `**SK** - Shared Kernel. Symmetric relationship: shared code/data requiring careful coordination between both contexts. Usage: \`A [SK] B\`${REL_LINK}`,
+    sharedkernel: `**SharedKernel** - Symmetric relationship: shared code/data requiring careful coordination between both contexts. Usage: \`A [SharedKernel] B\`${REL_LINK}`,
+    sw: `**SW** - Separate Ways. Symmetric relationship: contexts with no integration, solving problems independently. Usage: \`A [SW] B\` or \`A >< B\`${REL_LINK}`,
+    separateways: `**SeparateWays** - Symmetric relationship: contexts with no integration. Usage: \`A [SeparateWays] B\` or \`A >< B\`${REL_LINK}`,
 
     // ========================================================================
     // Relationship Arrows
     // ========================================================================
-    '->': `**->** - Unidirectional dependency (upstream to downstream).${REL_LINK}`,
-    '<->': `**<->** - Bidirectional dependency (mutual).${REL_LINK}`,
-    '<-': `**<-** - Reverse unidirectional dependency (downstream to upstream).${REL_LINK}`,
-    '><': `**><** - Separate Ways (no integration).${REL_LINK}`,
+    '->': `**->** - Directional: upstream (left) to downstream (right). Example: \`Orders [OHS] -> [CF] Payments\`${REL_LINK}`,
+    '<->': `**<->** - Bidirectional: both sides have patterns, mutual data flow. Example: \`Orders [OHS] <-> [CF] Payments\`${REL_LINK}`,
+    '<-': `**<-** - Reverse directional: upstream (right) to downstream (left). Example: \`Payments [ACL] <- Orders\`${REL_LINK}`,
+    '><': `**><** - Separate Ways: no integration between contexts. Equivalent to \`[SW]\`. Example: \`Orders >< Legacy\`${REL_LINK}`,
 };

package/src/sdk/ast-augmentation.ts

@@ -46,15 +46,19 @@
  * - `fqn` - Computed fully qualified name
  * - `hasType(name)` - Check type matches
  *
- * **Properties added to Relationship:**
- * - `hasPattern(pattern)` - Check if pattern exists on either side
- * - `hasLeftPattern(pattern)` - Check left patterns
- * - `hasRightPattern(pattern)` - Check right patterns
+ * **Properties added to DirectionalRelationship:**
+ * - `isBidirectional` - Check if relationship is bidirectional (`<->`)
+ * - `leftContextName` - Resolved name of left context (handles `this`)
+ * - `rightContextName` - Resolved name of right context (handles `this`)
+ * - `hasPattern(patternType)` - Check if pattern exists on either side
+ * - `hasLeftPattern(patternType)` - Check left patterns
+ * - `hasRightPattern(patternType)` - Check right patterns
  * - `isUpstream(side)` - Check if side is upstream
  * - `isDownstream(side)` - Check if side is downstream
- * - `isBidirectional` - Check if relationship is bidirectional
- * - `leftContextName` - Resolved name of left context
- * - `rightContextName` - Resolved name of right context
+ *
+ * **Properties added to SymmetricRelationship:**
+ * - `leftContextName` - Resolved name of left context (handles `this`)
+ * - `rightContextName` - Resolved name of right context (handles `this`)
  *
  * @module sdk/ast-augmentation
  */
@@ -109,9 +113,9 @@ declare module '../generated/ast.js' {
     }
 
     /**
-     * Augmented Relationship with SDK helper methods.
+     * Augmented DirectionalRelationship with SDK helper methods.
      */
-    interface Relationship {
+    interface DirectionalRelationship {
         /** Resolved name of left context (handles 'this') */
         readonly leftContextName: string;
         /** Resolved name of right context (handles 'this') */
@@ -120,36 +124,41 @@ declare module '../generated/ast.js' {
         readonly isBidirectional: boolean;
         
         /**
-         * Checks if the relationship has a specific integration pattern on either side.
-         * Accepts both abbreviations (SK, ACL) and full names (SharedKernel, AntiCorruptionLayer).
-         * @param pattern - Pattern abbreviation or full name
+         * Checks if the relationship has a specific side pattern on either side.
+         * Accepts pattern $type names like 'OpenHostService', 'Conformist', etc.
          */
-        hasPattern(pattern: import('./patterns.js').IntegrationPattern | string): boolean;
+        hasPattern(patternType: string): boolean;
         
         /**
-         * Checks if the left side has a specific integration pattern.
-         * @param pattern - Pattern abbreviation or full name
+         * Checks if the left side has a specific side pattern.
          */
-        hasLeftPattern(pattern: import('./patterns.js').IntegrationPattern | string): boolean;
+        hasLeftPattern(patternType: string): boolean;
         
         /**
-         * Checks if the right side has a specific integration pattern.
-         * @param pattern - Pattern abbreviation or full name
+         * Checks if the right side has a specific side pattern.
          */
-        hasRightPattern(pattern: import('./patterns.js').IntegrationPattern | string): boolean;
+        hasRightPattern(patternType: string): boolean;
         
         /**
          * Checks if the specified side is upstream (provider) in this relationship.
-         * @param side - 'left' or 'right'
          */
         isUpstream(side: 'left' | 'right'): boolean;
         
         /**
          * Checks if the specified side is downstream (consumer) in this relationship.
-         * @param side - 'left' or 'right'
          */
         isDownstream(side: 'left' | 'right'): boolean;
     }
+
+    /**
+     * Augmented SymmetricRelationship with SDK helper methods.
+     */
+    interface SymmetricRelationship {
+        /** Resolved name of left context (handles 'this') */
+        readonly leftContextName: string;
+        /** Resolved name of right context (handles 'this') */
+        readonly rightContextName: string;
+    }
 }
 
 // Export nothing - this file is purely for type augmentation

package/src/sdk/index.ts

@@ -116,14 +116,19 @@ export { fromModel, fromDocument, fromServices, augmentModel } from './query.js'
 export {
     Pattern,
     PatternFullName,
+    PatternAbbreviation,
     PatternAliases,
     matchesPattern,
     isUpstreamPattern,
     isDownstreamPattern,
     isMutualPattern,
+    isUpstreamSidePattern,
+    isDownstreamSidePattern,
+    isBBoMSidePattern,
+    getPatternAbbreviation,
     UpstreamPatterns,
     DownstreamPatterns,
-    MutualPatterns,
+    SymmetricPatterns,
 } from './patterns.js';
 
 export type { IntegrationPattern } from './patterns.js';
@@ -140,6 +145,11 @@ export type {
     LoadOptions,
     BcQueryBuilder,
     RelationshipView,
+    RelationshipSide,
+    DirectionalRelationshipView,
+    DirectionalKind,
+    SymmetricRelationshipView,
+    SymmetricKind,
 } from './types.js';
 
 // Serializers for tool responses (browser-safe)

package/src/sdk/loader-node.ts

@@ -62,7 +62,7 @@ export async function loadModel(
     options?: LoadOptions
 ): Promise<QueryContext> {
     // Resolve absolute path
-    const path = await import('path');
+    const path = await import('node:path');
     const absolutePath = path.isAbsolute(entryFile) 
         ? entryFile 
         : path.resolve(options?.workspaceDir ?? process.cwd(), entryFile);
@@ -82,7 +82,7 @@ export async function loadModel(
     }
     
     // Read file content and create document
-    const fs = await import('fs/promises');
+    const fs = await import('node:fs/promises');
     const fileContent = await fs.readFile(absolutePath, 'utf-8');
     const uri = URI.file(absolutePath);