pradeepmouli/rune-langium-core

@rune-langium/core

Documentation site and generated agent skills for rune-langium APIs

Use parse() for a single self-contained document, parseWorkspace() when files reference each other, and createRuneDslServices() when you need raw Langium services for custom tooling. The serializer exports are best for AST-driven workflows, tests, and code transformations that do not need to preserve original formatting.

When to Use

Use this skill when:

• Validating a single .rosetta file or snippet in memory → use parse
• Building a parse pipeline in a Node.js script → use parse
• Unit-testing grammar rules in isolation → use parse
• Generating code from a set of related .rosetta files → use parseWorkspace
• Validating a full namespace bundle where types reference each other → use parseWorkspace
• Running integration tests that span multiple Rosetta files → use parseWorkspace
• Building a Node.js script that parses or validates .rosetta files → use createRuneDslServices
• Writing unit tests for grammar rules or validators → use createRuneDslServices
• Constructing a parseWorkspace() pipeline outside of the LSP server → use createRuneDslServices
• Exporting a modified AST back to .rosetta format after programmatic edits → use serializeModel
• Generating a stub .rosetta file from a synthesized model object → use serializeModel
• Round-trip testing: parse → mutate → serialize → re-parse → use serializeModel
• Generating a snippet for one type definition without a full namespace header → use serializeElement
• Preview rendering a single type in editor UI → use serializeElement
• Batch-exporting a full CDM/DRR workspace to .rosetta files → use serializeModels
• Building a zip archive of serialized models keyed by namespace → use serializeModels
• This is used automatically by createRuneDslServices() → use RuneDslParser — you do not need to instantiate it directly.

Do NOT use when:

• Parsing files that have cross-references to other documents — unresolved references will have ref === undefined. Use parseWorkspace() instead. (parse)
• Running inside a Langium LSP server — the DocumentBuilder is already managed by the server lifecycle; calling parse() creates a second services instance and wastes memory. (parse)
• Parsing a single self-contained file — use the simpler parse() instead (parseWorkspace)
• Processing very large CDM workspaces incrementally — prefer the LSP server for streaming document updates (parseWorkspace)
• Inside the LSP server — use createRuneLspServer() which provides the full LangiumServices (LSP providers) instead of core-only services. (createRuneDslServices)
• When you need to share a service instance across multiple requests in a long-running server — the returned instance is not thread-safe for concurrent DocumentBuilder.build() calls; serialize builds with a queue. (createRuneDslServices)
• You need to preserve user-authored comments or whitespace — use a CST-preserving formatter instead. (serializeModel)
• The model contains RosettaFunction or RosettaRule elements — these are silently dropped; use the visual editor serializer for full round-trip fidelity. (serializeModel)
• Subclassing for grammar experiments — prefer creating a separate grammar variant and a new services container instead. (RuneDslParser)

API surface: 176 functions, 6 classes, 160 types, 149 constants

Configuration

RosettaQualifiableConfiguration (8 options — see references/config.md)

Quick Reference

Key functions: parse (Parse a Rosetta DSL source string into a typed AST), parseWorkspace (Parse multiple Rosetta DSL source strings as a workspace), createRuneDslServices (Create the full set of services required for the Rune DSL language), createRuneDslParser (Factory function that creates and fully initializes a RuneDslParser), insertImplicitBrackets (Scans Rune DSL source text and inserts [ and ] around bare expressions that follow extract, filter, or reduce operators), serializeModel (Serialize a single RosettaModel AST node back to ), serializeElement (Serialize a single AST element (Data, Choice, or RosettaEnumeration) to text), serializeModels(Serialize multipleRosettaModelnodes, returning aMapof namespace → source text) **Key classes:**RuneDslParser(Custom Langium parser for the Rune DSL that pre-processes input text to insert implicit[and]brackets around bare expressions afterextract, filter, and reduce` operators)

491 exports total — see references/ for full API.

References

Load these on demand — do NOT read all at once:

• When calling any function → browse references/functions/ for grouped indexes, full signatures, parameters, and return types
• When using a class → browse references/classes/ for grouped indexes, properties, methods, and inheritance
• When defining typed variables or function parameters → read references/types.md
• When using exported constants → read references/variables.md
• When configuring options → read references/config.md for all settings and defaults

Links

• Author: Pradeep Mouli [email protected] (https://github.com/pradeepmouli)