@domainlang/language 0.1.81

package/out/sdk/ast-augmentation.js

@@ -0,0 +1,62 @@
+/**
+ * SDK AST Augmentation - Module augmentation for native SDK properties.
+ *
+ * This file uses TypeScript's declaration merging to add computed helpers
+ * directly to the AST types. After importing this module, BoundedContext,
+ * Domain, and Relationship instances expose convenience getters.
+ *
+ * **Only properties that add value beyond direct AST access are augmented:**
+ * - Precedence resolution: `effectiveClassification`, `effectiveTeam` (for array-based properties)
+ * - Data transformation: `metadataMap` (array to Map)
+ * - Computed values: `fqn` (fully qualified name)
+ * - Helper methods: `hasClassification()`, `hasTeam()`, `hasMetadata()`, `hasType()`
+ *
+ * **Direct AST access (no augmentation needed):**
+ * - `bc.description` - Direct string property
+ * - `bc.businessModel?.ref` - Direct reference
+ * - `bc.evolution?.ref` - Direct reference
+ * - `bc.archetype?.ref` - Direct reference
+ * - `domain.description` - Direct string property
+ * - `domain.vision` - Direct string property
+ * - `domain.type?.ref` - Direct reference
+ *
+ * **Usage:**
+ * ```typescript
+ * import '../sdk/ast-augmentation.js'; // Enable augmented properties
+ * import { fromDocument } from '../sdk/index.js';
+ *
+ * fromDocument(document); // Ensures augmentation
+ * const bc: BoundedContext = ...;
+ * console.log(bc.effectiveClassification?.name);
+ * console.log(bc.metadataMap.get('Language'));
+ * // Direct access for simple properties:
+ * console.log(bc.businessModel?.ref?.name);
+ * ```
+ *
+ * **Properties added to BoundedContext:**
+ * - `effectiveClassification` - Inline `as` header → body `classification:`
+ * - `effectiveTeam` - Inline `team` header → body `team:`
+ * - `metadataMap` - Metadata entries exposed as a ReadonlyMap
+ * - `fqn` - Computed fully qualified name
+ * - `hasClassification(name)` - Check if classification matches
+ * - `hasTeam(name)` - Check if team matches
+ * - `hasMetadata(key, value?)` - Check metadata
+ *
+ * **Properties added to Domain:**
+ * - `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
+ * - `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
+ *
+ * @module sdk/ast-augmentation
+ */
+export {};
+//# sourceMappingURL=ast-augmentation.js.map

package/out/sdk/ast-augmentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-augmentation.js","sourceRoot":"","sources":["../../src/sdk/ast-augmentation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG"}

package/out/sdk/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Model Query SDK - Public API
+ *
+ * Provides fluent, type-safe query operations on DomainLang models.
+ *
+ * ## Architecture: SDK vs LSP Responsibilities
+ *
+ * The SDK is **read-only and query-focused**. It does NOT manage:
+ * - Workspace lifecycle (LSP/WorkspaceManager handles this)
+ * - File watching or change detection (LSP/TextDocuments handles this)
+ * - Cross-file import resolution (LSP/DocumentBuilder handles this)
+ * - Document validation scheduling (LSP handles this)
+ *
+ * **SDK responsibilities:**
+ * - Augmented AST properties (transparent property access with precedence rules)
+ * - Fluent query chains with lazy iteration
+ * - O(1) indexed lookups by FQN/name
+ * - Resolution rules (which block wins for 0..1 properties)
+ *
+ * **Entry points for different deployment targets:**
+ *
+ * | Target | Entry Point | Browser-Safe | Notes |
+ * |--------|-------------|--------------|-------|
+ * | VS Code Extension | `fromDocument()` | ✅ | Zero-copy LSP integration |
+ * | Web Editor | `fromDocument()`, `loadModelFromText()` | ✅ | Browser-compatible |
+ * | CLI (Node.js) | `loadModel()` from `sdk/loader-node` | ❌ | File system access |
+ * | Hosted LSP | `fromDocument()`, `fromServices()` | ✅ | Server-side only |
+ * | Testing | `loadModelFromText()` | ✅ | In-memory parsing |
+ *
+ * ## Browser vs Node.js
+ *
+ * This module (`sdk/index`) is **browser-safe** and exports only:
+ * - `loadModelFromText()` - uses EmptyFileSystem
+ * - `fromModel()`, `fromDocument()`, `fromServices()` - zero-copy wrappers
+ *
+ * For file-based loading in Node.js CLI tools:
+ * ```typescript
+ * import { loadModel } from 'domain-lang-language/sdk/loader-node';
+ * ```
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```typescript
+ * // Node.js CLI: Load from file (requires sdk/loader-node)
+ * import { loadModel } from 'domain-lang-language/sdk/loader-node';
+ *
+ * const { query } = await loadModel('./domains.dlang', {
+ *   workspaceDir: process.cwd()
+ * });
+ *
+ * const coreContexts = query.boundedContexts()
+ *   .withClassification('Core')
+ *   .withTeam('PaymentTeam');
+ *
+ * for (const bc of coreContexts) {
+ *   console.log(`${bc.name}: ${bc.description ?? 'n/a'}`);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Browser/Testing: Load from text (browser-safe)
+ * import { loadModelFromText } from '@domainlang/language/sdk';
+ *
+ * const { query } = await loadModelFromText(`
+ *   Domain Sales { vision: "Handle sales" }
+ *   bc OrderContext for Sales
+ * `);
+ *
+ * const sales = query.domain('Sales');
+ * console.log(sales?.vision);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // LSP Integration: Zero-copy access to existing AST (browser-safe)
+ * import { fromDocument } from '@domainlang/language/sdk';
+ *
+ * export class HoverProvider {
+ *   getHover(document: LangiumDocument<Model>) {
+ *     // SDK wraps existing AST - no reloading, no file I/O
+ *     const query = fromDocument(document);
+ *     const bc = query.boundedContext('OrderContext');
+ *     return bc?.description;
+ *   }
+ * }
+ * ```
+ */
+export { loadModelFromText } from './loader.js';
+export { fromModel, fromDocument, fromServices, augmentModel } from './query.js';
+export { Pattern, PatternFullName, PatternAliases, matchesPattern, isUpstreamPattern, isDownstreamPattern, isMutualPattern, UpstreamPatterns, DownstreamPatterns, MutualPatterns, } from './patterns.js';
+export type { IntegrationPattern } from './patterns.js';
+export type { Query, QueryBuilder, QueryContext, LoadOptions, BcQueryBuilder, RelationshipView, AugmentedBoundedContext, AugmentedDomain, } from './types.js';

package/out/sdk/index.js

@@ -0,0 +1,97 @@
+/**
+ * Model Query SDK - Public API
+ *
+ * Provides fluent, type-safe query operations on DomainLang models.
+ *
+ * ## Architecture: SDK vs LSP Responsibilities
+ *
+ * The SDK is **read-only and query-focused**. It does NOT manage:
+ * - Workspace lifecycle (LSP/WorkspaceManager handles this)
+ * - File watching or change detection (LSP/TextDocuments handles this)
+ * - Cross-file import resolution (LSP/DocumentBuilder handles this)
+ * - Document validation scheduling (LSP handles this)
+ *
+ * **SDK responsibilities:**
+ * - Augmented AST properties (transparent property access with precedence rules)
+ * - Fluent query chains with lazy iteration
+ * - O(1) indexed lookups by FQN/name
+ * - Resolution rules (which block wins for 0..1 properties)
+ *
+ * **Entry points for different deployment targets:**
+ *
+ * | Target | Entry Point | Browser-Safe | Notes |
+ * |--------|-------------|--------------|-------|
+ * | VS Code Extension | `fromDocument()` | ✅ | Zero-copy LSP integration |
+ * | Web Editor | `fromDocument()`, `loadModelFromText()` | ✅ | Browser-compatible |
+ * | CLI (Node.js) | `loadModel()` from `sdk/loader-node` | ❌ | File system access |
+ * | Hosted LSP | `fromDocument()`, `fromServices()` | ✅ | Server-side only |
+ * | Testing | `loadModelFromText()` | ✅ | In-memory parsing |
+ *
+ * ## Browser vs Node.js
+ *
+ * This module (`sdk/index`) is **browser-safe** and exports only:
+ * - `loadModelFromText()` - uses EmptyFileSystem
+ * - `fromModel()`, `fromDocument()`, `fromServices()` - zero-copy wrappers
+ *
+ * For file-based loading in Node.js CLI tools:
+ * ```typescript
+ * import { loadModel } from 'domain-lang-language/sdk/loader-node';
+ * ```
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```typescript
+ * // Node.js CLI: Load from file (requires sdk/loader-node)
+ * import { loadModel } from 'domain-lang-language/sdk/loader-node';
+ *
+ * const { query } = await loadModel('./domains.dlang', {
+ *   workspaceDir: process.cwd()
+ * });
+ *
+ * const coreContexts = query.boundedContexts()
+ *   .withClassification('Core')
+ *   .withTeam('PaymentTeam');
+ *
+ * for (const bc of coreContexts) {
+ *   console.log(`${bc.name}: ${bc.description ?? 'n/a'}`);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Browser/Testing: Load from text (browser-safe)
+ * import { loadModelFromText } from '@domainlang/language/sdk';
+ *
+ * const { query } = await loadModelFromText(`
+ *   Domain Sales { vision: "Handle sales" }
+ *   bc OrderContext for Sales
+ * `);
+ *
+ * const sales = query.domain('Sales');
+ * console.log(sales?.vision);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // LSP Integration: Zero-copy access to existing AST (browser-safe)
+ * import { fromDocument } from '@domainlang/language/sdk';
+ *
+ * export class HoverProvider {
+ *   getHover(document: LangiumDocument<Model>) {
+ *     // SDK wraps existing AST - no reloading, no file I/O
+ *     const query = fromDocument(document);
+ *     const bc = query.boundedContext('OrderContext');
+ *     return bc?.description;
+ *   }
+ * }
+ * ```
+ */
+// Browser-safe entry points
+export { loadModelFromText } from './loader.js';
+export { fromModel, fromDocument, fromServices, augmentModel } from './query.js';
+// Note: loadModel() is NOT exported here - it requires Node.js filesystem
+// For CLI/Node.js usage: import { loadModel } from '@domainlang/language/sdk/loader-node';
+// Integration patterns for type-safe pattern matching (no magic strings)
+export { Pattern, PatternFullName, PatternAliases, matchesPattern, isUpstreamPattern, isDownstreamPattern, isMutualPattern, UpstreamPatterns, DownstreamPatterns, MutualPatterns, } from './patterns.js';
+//# sourceMappingURL=index.js.map

package/out/sdk/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AAEH,4BAA4B;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjF,0EAA0E;AAC1E,2FAA2F;AAE3F,yEAAyE;AACzE,OAAO,EACH,OAAO,EACP,eAAe,EACf,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,GACjB,MAAM,eAAe,CAAC"}

package/out/sdk/indexes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Index building for O(1) lookups in the Model Query SDK.
+ * Builds maps for FQN, name, team, strategic classification, and metadata lookups.
+ *
+ * Indexes are built once during model loading and enable fast queries.
+ */
+import type { Model } from '../generated/ast.js';
+import type { ModelIndexes } from './types.js';
+/**
+ * Builds all indexes for a model.
+ * Called once during model loading.
+ *
+ * @param model - Root model node
+ * @returns ModelIndexes containing all lookup maps
+ */
+export declare function buildIndexes(model: Model): ModelIndexes;

package/out/sdk/indexes.js

@@ -0,0 +1,97 @@
+/**
+ * Index building for O(1) lookups in the Model Query SDK.
+ * Builds maps for FQN, name, team, strategic classification, and metadata lookups.
+ *
+ * Indexes are built once during model loading and enable fast queries.
+ */
+import { AstUtils } from 'langium';
+import { isBoundedContext, isClassification, isContextMap, isDomain, isDomainMap, isMetadata, isNamespaceDeclaration, isTeam, } from '../generated/ast.js';
+import { QualifiedNameProvider } from '../lsp/domain-lang-naming.js';
+import { metadataAsMap, effectiveClassification, effectiveTeam, } from './resolution.js';
+/**
+ * Builds all indexes for a model.
+ * Called once during model loading.
+ *
+ * @param model - Root model node
+ * @returns ModelIndexes containing all lookup maps
+ */
+export function buildIndexes(model) {
+    const byFqn = new Map();
+    const byName = new Map();
+    const byTeam = new Map();
+    const byClassification = new Map();
+    const byMetadataKey = new Map();
+    const fqnProvider = new QualifiedNameProvider();
+    // Stream all AST nodes and index them
+    for (const node of AstUtils.streamAllContents(model)) {
+        // Index named types only
+        if (!hasName(node)) {
+            continue;
+        }
+        const name = node.name;
+        const fqn = fqnProvider.getQualifiedName(node.$container, name);
+        // Index by FQN (unique)
+        byFqn.set(fqn, node);
+        // Index by simple name (may have duplicates)
+        const nameList = byName.get(name) ?? [];
+        nameList.push(node);
+        byName.set(name, nameList);
+        // BoundedContext-specific indexes
+        if (isBoundedContext(node)) {
+            indexBoundedContext(node, byTeam, byClassification, byMetadataKey);
+        }
+    }
+    return {
+        byFqn,
+        byName,
+        byTeam,
+        byClassification,
+        byMetadataKey,
+    };
+}
+/**
+ * Indexes a BoundedContext by team, strategic classification, and metadata.
+ *
+ * @param bc - BoundedContext node
+ * @param byTeam - Team index map
+ * @param byClassification - Strategic classification index map
+ * @param byMetadataKey - Metadata key index map
+ */
+function indexBoundedContext(bc, byTeam, byClassification, byMetadataKey) {
+    // Index by team
+    const team = effectiveTeam(bc);
+    if (team?.name) {
+        const teamList = byTeam.get(team.name) ?? [];
+        teamList.push(bc);
+        byTeam.set(team.name, teamList);
+    }
+    // Index by strategic classification
+    const classification = effectiveClassification(bc);
+    if (classification?.name) {
+        const classificationList = byClassification.get(classification.name) ?? [];
+        classificationList.push(bc);
+        byClassification.set(classification.name, classificationList);
+    }
+    // Index by metadata keys
+    const metadata = metadataAsMap(bc);
+    for (const key of metadata.keys()) {
+        const metaList = byMetadataKey.get(key) ?? [];
+        metaList.push(bc);
+        byMetadataKey.set(key, metaList);
+    }
+}
+/**
+ * Type guard for named AST nodes.
+ * Only these types are indexed by name.
+ */
+function hasName(node) {
+    return (isDomain(node) ||
+        isBoundedContext(node) ||
+        isTeam(node) ||
+        isClassification(node) ||
+        isContextMap(node) ||
+        isDomainMap(node) ||
+        isNamespaceDeclaration(node) ||
+        isMetadata(node));
+}
+//# sourceMappingURL=indexes.js.map

package/out/sdk/indexes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexes.js","sourceRoot":"","sources":["../../src/sdk/indexes.ts"],"names":[],"mappings":"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"}

package/out/sdk/loader-node.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Node.js-specific loader for DomainLang models.
+ *
+ * **WARNING: This module is NOT browser-compatible.**
+ *
+ * For browser environments, use:
+ * - `fromDocument()` with documents from the LSP
+ * - `fromModel()` with pre-parsed models
+ * - `loadModelFromText()` for in-memory parsing
+ *
+ * This loader creates **isolated Langium services** for standalone CLI usage.
+ * It does NOT integrate with an existing LSP workspace.
+ *
+ * For full workspace management with cross-file imports:
+ * - Use the WorkspaceManager service
+ * - Or host the LSP server and use its services
+ *
+ * @module sdk/loader-node
+ */
+import type { LoadOptions, QueryContext } from './types.js';
+/**
+ * Loads a DomainLang model from a file on disk.
+ *
+ * **Node.js only** - uses file system APIs.
+ *
+ * Note: This loads a single file. For multi-file models with imports,
+ * consider using the WorkspaceManager or hosting an LSP server.
+ *
+ * @param entryFile - Path to the entry .dlang file
+ * @param options - Optional load configuration
+ * @returns QueryContext with model, documents, and query API
+ * @throws Error if file cannot be loaded or parsing fails
+ *
+ * @example
+ * ```typescript
+ * import { loadModel } from '@domainlang/language/sdk/loader-node';
+ *
+ * const { query, model } = await loadModel('./domains.dlang', {
+ *   workspaceDir: process.cwd()
+ * });
+ *
+ * for (const bc of query.boundedContexts()) {
+ *   console.log(bc.name);
+ * }
+ * ```
+ */
+export declare function loadModel(entryFile: string, options?: LoadOptions): Promise<QueryContext>;

package/out/sdk/loader-node.js

@@ -0,0 +1,104 @@
+/**
+ * Node.js-specific loader for DomainLang models.
+ *
+ * **WARNING: This module is NOT browser-compatible.**
+ *
+ * For browser environments, use:
+ * - `fromDocument()` with documents from the LSP
+ * - `fromModel()` with pre-parsed models
+ * - `loadModelFromText()` for in-memory parsing
+ *
+ * This loader creates **isolated Langium services** for standalone CLI usage.
+ * It does NOT integrate with an existing LSP workspace.
+ *
+ * For full workspace management with cross-file imports:
+ * - Use the WorkspaceManager service
+ * - Or host the LSP server and use its services
+ *
+ * @module sdk/loader-node
+ */
+import { DocumentState, URI } from 'langium';
+import { NodeFileSystem } from 'langium/node';
+import { isModel } from '../generated/ast.js';
+import { createDomainLangServices } from '../domain-lang-module.js';
+import { fromModel, augmentModel } from './query.js';
+/**
+ * Loads a DomainLang model from a file on disk.
+ *
+ * **Node.js only** - uses file system APIs.
+ *
+ * Note: This loads a single file. For multi-file models with imports,
+ * consider using the WorkspaceManager or hosting an LSP server.
+ *
+ * @param entryFile - Path to the entry .dlang file
+ * @param options - Optional load configuration
+ * @returns QueryContext with model, documents, and query API
+ * @throws Error if file cannot be loaded or parsing fails
+ *
+ * @example
+ * ```typescript
+ * import { loadModel } from '@domainlang/language/sdk/loader-node';
+ *
+ * const { query, model } = await loadModel('./domains.dlang', {
+ *   workspaceDir: process.cwd()
+ * });
+ *
+ * for (const bc of query.boundedContexts()) {
+ *   console.log(bc.name);
+ * }
+ * ```
+ */
+export async function loadModel(entryFile, options) {
+    // Resolve absolute path
+    const path = await import('path');
+    const absolutePath = path.isAbsolute(entryFile)
+        ? entryFile
+        : path.resolve(options?.workspaceDir ?? process.cwd(), entryFile);
+    // Create or reuse services
+    const servicesObj = options?.services
+        ? { shared: options.services.shared, DomainLang: options.services }
+        : createDomainLangServices(NodeFileSystem);
+    const services = servicesObj.DomainLang;
+    const shared = servicesObj.shared;
+    // Initialize workspace if directory provided
+    if (options?.workspaceDir) {
+        const workspaceManager = services.imports.WorkspaceManager;
+        await workspaceManager.initialize(options.workspaceDir);
+    }
+    // Read file content and create document
+    const fs = await import('fs/promises');
+    const fileContent = await fs.readFile(absolutePath, 'utf-8');
+    const uri = URI.file(absolutePath);
+    // Use proper Langium document creation
+    const document = shared.workspace.LangiumDocumentFactory.fromString(fileContent, uri);
+    // Register document and build it
+    shared.workspace.LangiumDocuments.addDocument(document);
+    await shared.workspace.DocumentBuilder.build([document], { validation: true });
+    // Wait for document to be fully processed
+    if (document.state < DocumentState.Validated) {
+        throw new Error(`Document not fully processed: ${absolutePath}`);
+    }
+    // Check for parsing errors
+    if (document.parseResult.lexerErrors.length > 0) {
+        const errors = document.parseResult.lexerErrors.map(e => e.message).join('\n  ');
+        throw new Error(`Lexer errors in ${entryFile}:\n  ${errors}`);
+    }
+    if (document.parseResult.parserErrors.length > 0) {
+        const errors = document.parseResult.parserErrors.map(e => e.message).join('\n  ');
+        throw new Error(`Parser errors in ${entryFile}:\n  ${errors}`);
+    }
+    const model = document.parseResult.value;
+    if (!isModel(model)) {
+        throw new Error(`Document root is not a Model: ${entryFile}`);
+    }
+    // Augment AST nodes with SDK properties
+    augmentModel(model);
+    // Collect all document URIs
+    const documentUris = Array.from(shared.workspace.LangiumDocuments.all).map(doc => doc.uri);
+    return {
+        model,
+        documents: documentUris,
+        query: fromModel(model),
+    };
+}
+//# sourceMappingURL=loader-node.js.map

package/out/sdk/loader-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader-node.js","sourceRoot":"","sources":["../../src/sdk/loader-node.ts"],"names":[],"mappings":"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"}

package/out/sdk/loader.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Browser-safe loader for in-memory model parsing.
+ *
+ * This module provides `loadModelFromText()` which works in both
+ * browser and Node.js environments by using Langium's EmptyFileSystem.
+ *
+ * For file-based loading in Node.js CLI tools, use:
+ * ```typescript
+ * import { loadModel } from '@domainlang/language/sdk/loader-node';
+ * ```
+ *
+ * For LSP/validation code that already has a linked AST, use the sync entry points:
+ * - `fromDocument()` - from a LangiumDocument
+ * - `fromModel()` - from a Model AST node
+ * - `fromServices()` - from DomainLangServices container
+ *
+ * @module sdk/loader
+ */
+import type { LoadOptions, QueryContext } from './types.js';
+/**
+ * Loads a DomainLang model from a text string.
+ *
+ * **Browser-safe** - uses in-memory file system (EmptyFileSystem).
+ *
+ * Useful for:
+ * - Testing
+ * - REPL environments
+ * - Web-based editors
+ * - Any environment without file system access
+ *
+ * @param text - DomainLang source code
+ * @param options - Optional load configuration
+ * @returns QueryContext with model and query API
+ * @throws Error if parsing fails
+ *
+ * @example
+ * ```typescript
+ * import { loadModelFromText } from '@domainlang/language/sdk';
+ *
+ * const { query } = await loadModelFromText(`
+ *   Domain Sales { vision: "Handle sales" }
+ *   bc OrderContext for Sales
+ * `);
+ *
+ * const sales = query.domain('Sales');
+ * console.log(sales?.resolvedVision);
+ * ```
+ */
+export declare function loadModelFromText(text: string, options?: LoadOptions): Promise<QueryContext>;

package/out/sdk/loader.js

@@ -0,0 +1,85 @@
+/**
+ * Browser-safe loader for in-memory model parsing.
+ *
+ * This module provides `loadModelFromText()` which works in both
+ * browser and Node.js environments by using Langium's EmptyFileSystem.
+ *
+ * For file-based loading in Node.js CLI tools, use:
+ * ```typescript
+ * import { loadModel } from '@domainlang/language/sdk/loader-node';
+ * ```
+ *
+ * For LSP/validation code that already has a linked AST, use the sync entry points:
+ * - `fromDocument()` - from a LangiumDocument
+ * - `fromModel()` - from a Model AST node
+ * - `fromServices()` - from DomainLangServices container
+ *
+ * @module sdk/loader
+ */
+import { EmptyFileSystem, URI } from 'langium';
+import { isModel } from '../generated/ast.js';
+import { createDomainLangServices } from '../domain-lang-module.js';
+import { augmentModel, fromModel } from './query.js';
+/**
+ * Loads a DomainLang model from a text string.
+ *
+ * **Browser-safe** - uses in-memory file system (EmptyFileSystem).
+ *
+ * Useful for:
+ * - Testing
+ * - REPL environments
+ * - Web-based editors
+ * - Any environment without file system access
+ *
+ * @param text - DomainLang source code
+ * @param options - Optional load configuration
+ * @returns QueryContext with model and query API
+ * @throws Error if parsing fails
+ *
+ * @example
+ * ```typescript
+ * import { loadModelFromText } from '@domainlang/language/sdk';
+ *
+ * const { query } = await loadModelFromText(`
+ *   Domain Sales { vision: "Handle sales" }
+ *   bc OrderContext for Sales
+ * `);
+ *
+ * const sales = query.domain('Sales');
+ * console.log(sales?.resolvedVision);
+ * ```
+ */
+export async function loadModelFromText(text, options) {
+    // Create or reuse services (use EmptyFileSystem for in-memory parsing)
+    const servicesObj = options?.services
+        ? { shared: options.services.shared, DomainLang: options.services }
+        : createDomainLangServices(EmptyFileSystem);
+    const shared = servicesObj.shared;
+    // Create document from text with a virtual URI
+    const uri = URI.parse('memory:///model.dlang');
+    const document = shared.workspace.LangiumDocumentFactory.fromString(text, uri);
+    // Register and build document
+    shared.workspace.LangiumDocuments.addDocument(document);
+    await shared.workspace.DocumentBuilder.build([document], { validation: true });
+    // Check for parsing errors
+    if (document.parseResult.lexerErrors.length > 0) {
+        const errors = document.parseResult.lexerErrors.map(e => e.message).join('\n  ');
+        throw new Error(`Lexer errors:\n  ${errors}`);
+    }
+    if (document.parseResult.parserErrors.length > 0) {
+        const errors = document.parseResult.parserErrors.map(e => e.message).join('\n  ');
+        throw new Error(`Parser errors:\n  ${errors}`);
+    }
+    const model = document.parseResult.value;
+    if (!isModel(model)) {
+        throw new Error(`Document root is not a Model`);
+    }
+    // Augment AST nodes with SDK properties
+    augmentModel(model);
+    return {
+        model,
+        documents: [document.uri],
+        query: fromModel(model),
+    };
+}
+//# sourceMappingURL=loader.js.map