@zenstackhq/language 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/index.cjs

@@ -31,7 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  DocumentLoadError: () => DocumentLoadError,
+  ZModelCodeGenerator: () => ZModelCodeGenerator,
   ZModelLanguageMetaData: () => ZModelLanguageMetaData,
   ZModelLanguageModule: () => ZModelLanguageModule,
   ZModelSharedModule: () => ZModelSharedModule,
@@ -40,15 +40,20 @@ __export(src_exports, {
   loadDocument: () => loadDocument
 });
 module.exports = __toCommonJS(src_exports);
-var import_langium11 = require("langium");
-var import_node = require("langium/node");
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-var import_node_url2 = require("url");
+
+// src/document.ts
+var import_langium14 = require("langium");
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_url4 = require("url");
 
 // src/generated/ast.ts
 var langium = __toESM(require("langium"), 1);
 var AbstractDeclaration = "AbstractDeclaration";
+function isAbstractDeclaration(item) {
+  return reflection.isInstance(item, AbstractDeclaration);
+}
+__name(isAbstractDeclaration, "isAbstractDeclaration");
 var ConfigExpr = "ConfigExpr";
 var Expression = "Expression";
 function isExpression(item) {
@@ -75,6 +80,10 @@ function isAttribute(item) {
 }
 __name(isAttribute, "isAttribute");
 var AttributeArg = "AttributeArg";
+function isAttributeArg(item) {
+  return reflection.isInstance(item, AttributeArg);
+}
+__name(isAttributeArg, "isAttributeArg");
 var AttributeParam = "AttributeParam";
 var AttributeParamType = "AttributeParamType";
 var BinaryExpr = "BinaryExpr";
@@ -93,6 +102,10 @@ function isConfigArrayExpr(item) {
 }
 __name(isConfigArrayExpr, "isConfigArrayExpr");
 var ConfigField = "ConfigField";
+function isConfigField(item) {
+  return reflection.isInstance(item, ConfigField);
+}
+__name(isConfigField, "isConfigField");
 var ConfigInvocationArg = "ConfigInvocationArg";
 var ConfigInvocationExpr = "ConfigInvocationExpr";
 var DataField = "DataField";
@@ -137,10 +150,22 @@ function isEnumField(item) {
 __name(isEnumField, "isEnumField");
 var FieldInitializer = "FieldInitializer";
 var FunctionDecl = "FunctionDecl";
+function isFunctionDecl(item) {
+  return reflection.isInstance(item, FunctionDecl);
+}
+__name(isFunctionDecl, "isFunctionDecl");
 var FunctionParam = "FunctionParam";
 var FunctionParamType = "FunctionParamType";
 var GeneratorDecl = "GeneratorDecl";
+function isGeneratorDecl(item) {
+  return reflection.isInstance(item, GeneratorDecl);
+}
+__name(isGeneratorDecl, "isGeneratorDecl");
 var InternalAttribute = "InternalAttribute";
+function isInternalAttribute(item) {
+  return reflection.isInstance(item, InternalAttribute);
+}
+__name(isInternalAttribute, "isInternalAttribute");
 var InvocationExpr = "InvocationExpr";
 function isInvocationExpr(item) {
   return reflection.isInstance(item, InvocationExpr);
@@ -157,6 +182,10 @@ function isModel(item) {
 }
 __name(isModel, "isModel");
 var ModelImport = "ModelImport";
+function isModelImport(item) {
+  return reflection.isInstance(item, ModelImport);
+}
+__name(isModelImport, "isModelImport");
 var NullExpr = "NullExpr";
 function isNullExpr(item) {
   return reflection.isInstance(item, NullExpr);
@@ -178,6 +207,10 @@ function isPlugin(item) {
 }
 __name(isPlugin, "isPlugin");
 var PluginField = "PluginField";
+function isPluginField(item) {
+  return reflection.isInstance(item, PluginField);
+}
+__name(isPluginField, "isPluginField");
 var Procedure = "Procedure";
 var ProcedureParam = "ProcedureParam";
 var ReferenceArg = "ReferenceArg";
@@ -1044,6 +1077,26 @@ var ZModelAstReflection = class extends langium.AbstractAstReflection {
 };
 var reflection = new ZModelAstReflection();
 
+// src/ast.ts
+var BinaryExprOperatorPriority = {
+  //LogicalExpr
+  "||": 1,
+  "&&": 1,
+  //EqualityExpr
+  "==": 2,
+  "!=": 2,
+  //ComparisonExpr
+  ">": 3,
+  "<": 3,
+  ">=": 3,
+  "<=": 3,
+  in: 4,
+  //CollectionPredicateExpr
+  "^": 5,
+  "?": 5,
+  "!": 5
+};
+
 // src/constants.ts
 var SUPPORTED_PROVIDERS = [
   "sqlite",
@@ -1074,8 +1127,11 @@ var ExpressionContext = /* @__PURE__ */ function(ExpressionContext2) {
 }({});
 
 // src/module.ts
-var import_langium10 = require("langium");
-var import_lsp = require("langium/lsp");
+var import_langium13 = require("langium");
+var import_lsp5 = require("langium/lsp");
+var import_node = require("langium/node");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_url3 = require("url");
 
 // src/generated/grammar.ts
 var import_langium = require("langium");
@@ -5136,15 +5192,13 @@ var ZModelGeneratedModule = {
   parser: {}
 };
 
-// src/validators/attribute-application-validator.ts
-var import_langium3 = require("langium");
-var import_pluralize = __toESM(require("pluralize"), 1);
-
 // src/utils.ts
-var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_langium2 = require("langium");
 var import_node_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
+var import_node_module = require("module");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_meta = {};
 function hasAttribute(decl, name) {
   return !!getAttribute(decl, name);
 }
@@ -5224,10 +5278,6 @@ function isRelationshipField(field) {
   return isDataModel(field.type.reference?.ref);
 }
 __name(isRelationshipField, "isRelationshipField");
-function isFutureExpr(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "future" && isFromStdlib(node.function.ref);
-}
-__name(isFutureExpr, "isFutureExpr");
 function isDelegateModel(node) {
   return isDataModel(node) && hasAttribute(node, "@@delegate");
 }
@@ -5245,8 +5295,14 @@ function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */
     return result;
   }
   seen.add(decl);
-  decl.mixins.forEach((mixin) => {
-    const baseDecl = mixin.ref;
+  const bases = [
+    ...decl.mixins,
+    ...isDataModel(decl) && decl.baseModel ? [
+      decl.baseModel
+    ] : []
+  ];
+  bases.forEach((base) => {
+    const baseDecl = decl.$container.declarations.find((d) => isTypeDef(d) || isDataModel(d) && d.name === base.$refText);
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -5386,7 +5442,7 @@ function getFunctionExpressionContext(funcDecl) {
 }
 __name(getFunctionExpressionContext, "getFunctionExpressionContext");
 function isCheckInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "check" && isFromStdlib(node.function.ref);
+  return isInvocationExpr(node) && node.function.ref?.name === "check";
 }
 __name(isCheckInvocation, "isCheckInvocation");
 function resolveTransitiveImports(documents, model) {
@@ -5436,9 +5492,9 @@ function resolveImportUri(imp) {
     return void 0;
   }
   const doc = import_langium2.AstUtils.getDocument(imp);
-  const dir = import_path.default.dirname(doc.uri.fsPath);
+  const dir = import_node_path.default.dirname(doc.uri.fsPath);
   const importPath = imp.path.endsWith(".zmodel") ? imp.path : `${imp.path}.zmodel`;
-  return import_langium2.URI.file(import_path.default.resolve(dir, importPath));
+  return import_langium2.URI.file(import_node_path.default.resolve(dir, importPath));
 }
 __name(resolveImportUri, "resolveImportUri");
 function getDataModelAndTypeDefs(model, includeIgnored = false) {
@@ -5456,17 +5512,17 @@ function getAllDeclarationsIncludingImports(documents, model) {
 }
 __name(getAllDeclarationsIncludingImports, "getAllDeclarationsIncludingImports");
 function getAuthDecl(decls) {
-  let authModel = decls.find((m) => hasAttribute(m, "@@auth"));
+  let authModel = decls.find((d) => hasAttribute(d, "@@auth"));
   if (!authModel) {
-    authModel = decls.find((m) => m.name === "User");
+    authModel = decls.find((d) => d.name === "User");
   }
   return authModel;
 }
 __name(getAuthDecl, "getAuthDecl");
-function isFutureInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "future" && isFromStdlib(node.function.ref);
+function isBeforeInvocation(node) {
+  return isInvocationExpr(node) && node.function.ref?.name === "before";
 }
-__name(isFutureInvocation, "isFutureInvocation");
+__name(isBeforeInvocation, "isBeforeInvocation");
 function isCollectionPredicate(node) {
   return isBinaryExpr(node) && [
     "?",
@@ -5521,12 +5577,14 @@ function getAllFields(decl, includeIgnored = false, seen = /* @__PURE__ */ new S
   seen.add(decl);
   const fields = [];
   for (const mixin of decl.mixins) {
-    (0, import_common_helpers.invariant)(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
-    fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+    if (mixin.ref) {
+      fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+    }
   }
   if (isDataModel(decl) && decl.baseModel) {
-    (0, import_common_helpers.invariant)(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
-    fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+    if (decl.baseModel.ref) {
+      fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+    }
   }
   fields.push(...decl.fields.filter((f) => includeIgnored || !hasAttribute(f, "@ignore")));
   return fields;
@@ -5539,12 +5597,14 @@ function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
   seen.add(decl);
   const attributes = [];
   for (const mixin of decl.mixins) {
-    (0, import_common_helpers.invariant)(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
-    attributes.push(...getAllAttributes(mixin.ref, seen));
+    if (mixin.ref) {
+      attributes.push(...getAllAttributes(mixin.ref, seen));
+    }
   }
   if (isDataModel(decl) && decl.baseModel) {
-    (0, import_common_helpers.invariant)(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
-    attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    if (decl.baseModel.ref) {
+      attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    }
   }
   attributes.push(...decl.attributes);
   return attributes;
@@ -5559,6 +5619,71 @@ function getDocument(node) {
   return result;
 }
 __name(getDocument, "getDocument");
+function getPluginDocuments(model, schemaPath) {
+  const result = [];
+  for (const decl of model.declarations.filter(isPlugin)) {
+    const providerField = decl.fields.find((f) => f.name === "provider");
+    if (!providerField) {
+      continue;
+    }
+    const provider = getLiteral(providerField.value);
+    if (!provider) {
+      continue;
+    }
+    let pluginModelFile;
+    let providerPath = import_node_path.default.resolve(import_node_path.default.dirname(schemaPath), provider);
+    if (import_node_fs.default.existsSync(providerPath)) {
+      if (import_node_fs.default.statSync(providerPath).isDirectory()) {
+        providerPath = import_node_path.default.join(providerPath, "index.js");
+      }
+      pluginModelFile = import_node_path.default.resolve(import_node_path.default.dirname(providerPath), PLUGIN_MODULE_NAME);
+      if (!import_node_fs.default.existsSync(pluginModelFile)) {
+        pluginModelFile = findUp([
+          PLUGIN_MODULE_NAME
+        ], import_node_path.default.dirname(providerPath));
+      }
+    }
+    if (!pluginModelFile) {
+      if (typeof import_meta.resolve === "function") {
+        try {
+          const resolvedUrl = import_meta.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+          pluginModelFile = (0, import_node_url.fileURLToPath)(resolvedUrl);
+        } catch {
+        }
+      }
+    }
+    if (!pluginModelFile) {
+      try {
+        const require2 = (0, import_node_module.createRequire)((0, import_node_url.pathToFileURL)(schemaPath));
+        pluginModelFile = require2.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+      } catch {
+      }
+    }
+    if (pluginModelFile && import_node_fs.default.existsSync(pluginModelFile)) {
+      result.push(pluginModelFile);
+    }
+  }
+  return result;
+}
+__name(getPluginDocuments, "getPluginDocuments");
+function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
+  if (!names.some((name) => !!name)) {
+    return void 0;
+  }
+  const target = names.find((name) => import_node_fs.default.existsSync(import_node_path.default.join(cwd, name)));
+  if (multiple === false && target) {
+    return import_node_path.default.join(cwd, target);
+  }
+  if (target) {
+    result.push(import_node_path.default.join(cwd, target));
+  }
+  const up = import_node_path.default.resolve(cwd, "..");
+  if (up === cwd) {
+    return multiple && result.length > 0 ? result : void 0;
+  }
+  return findUp(names, up, multiple, result);
+}
+__name(findUp, "findUp");
 function findRootNode(node) {
   while (node.$container) {
     node = node.$container;
@@ -5568,6 +5693,8 @@ function findRootNode(node) {
 __name(findRootNode, "findRootNode");
 
 // src/validators/attribute-application-validator.ts
+var import_langium3 = require("langium");
+var import_pluralize = __toESM(require("pluralize"), 1);
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -5681,6 +5808,7 @@ var AttributeApplicationValidator = class {
       });
     }
   }
+  // TODO: design a way to let plugin register validation
   _checkModelLevelPolicy(attr, accept) {
     const kind = getStringLiteral(attr.args[0]?.value);
     if (!kind) {
@@ -5693,11 +5821,61 @@ var AttributeApplicationValidator = class {
       "create",
       "read",
       "update",
+      "post-update",
       "delete",
       "all"
     ], attr, accept);
-    this.rejectEncryptedFields(attr, accept);
+    if ((kind === "create" || kind === "all") && attr.args[1]?.value) {
+      this.rejectNonOwnedRelationInExpression(attr.args[1].value, accept);
+    }
+    if (kind !== "post-update" && attr.args[1]?.value) {
+      const beforeCall = import_langium3.AstUtils.streamAst(attr.args[1]?.value).find(isBeforeInvocation);
+      if (beforeCall) {
+        accept("error", `"before()" is only allowed in "post-update" policy rules`, {
+          node: beforeCall
+        });
+      }
+    }
   }
+  rejectNonOwnedRelationInExpression(expr, accept) {
+    const contextModel = import_langium3.AstUtils.getContainerOfType(expr, isDataModel);
+    if (!contextModel) {
+      return;
+    }
+    if (import_langium3.AstUtils.streamAst(expr).some((node) => {
+      if (!isDataFieldReference(node)) {
+        return false;
+      }
+      if (node.target.ref?.$container !== contextModel) {
+        return false;
+      }
+      const field = node.target.ref;
+      if (!isRelationshipField(field)) {
+        return false;
+      }
+      if (isAuthOrAuthMemberAccess(node)) {
+        return false;
+      }
+      const startNode = isCollectionPredicate(node.$container) && node.$container.left === node ? node.$container : node;
+      const collectionPredicate = import_langium3.AstUtils.getContainerOfType(startNode.$container, isCollectionPredicate);
+      if (collectionPredicate && isAuthOrAuthMemberAccess(collectionPredicate.left)) {
+        return false;
+      }
+      const relationAttr = field.attributes.find((attr) => attr.decl.ref?.name === "@relation");
+      if (!relationAttr) {
+        return true;
+      }
+      if (!relationAttr.args.some((arg) => arg.name === "fields")) {
+        return true;
+      }
+      return false;
+    })) {
+      accept("error", `non-owned relation fields are not allowed in "create" rules`, {
+        node: expr
+      });
+    }
+  }
+  // TODO: design a way to let plugin register validation
   _checkFieldLevelPolicy(attr, accept) {
     const kind = getStringLiteral(attr.args[0]?.value);
     if (!kind) {
@@ -5712,8 +5890,8 @@ var AttributeApplicationValidator = class {
       "all"
     ], attr, accept);
     const expr = attr.args[1]?.value;
-    if (expr && import_langium3.AstUtils.streamAst(expr).some((node) => isFutureExpr(node))) {
-      accept("error", `"future()" is not allowed in field-level policy rules`, {
+    if (expr && import_langium3.AstUtils.streamAst(expr).some((node) => isBeforeInvocation(node))) {
+      accept("error", `"before()" is not allowed in field-level policy rules`, {
         node: expr
       });
     }
@@ -5725,7 +5903,6 @@ var AttributeApplicationValidator = class {
         });
       }
     }
-    this.rejectEncryptedFields(attr, accept);
   }
   _checkValidate(attr, accept) {
     const condition = attr.args[0]?.value;
@@ -5735,8 +5912,9 @@ var AttributeApplicationValidator = class {
       });
     }
   }
-  _checkUnique(attr, accept) {
+  _checkConstraint(attr, accept) {
     const fields = attr.args[0]?.value;
+    const attrName = attr.decl.ref?.name;
     if (!fields) {
       accept("error", `expects an array of field references`, {
         node: attr.args[0]
@@ -5745,7 +5923,7 @@ var AttributeApplicationValidator = class {
     }
     if (isArrayExpr(fields)) {
       if (fields.items.length === 0) {
-        accept("error", `\`@@unique\` expects at least one field reference`, {
+        accept("error", `\`${attrName}\` expects at least one field reference`, {
           node: fields
         });
         return;
@@ -5764,7 +5942,7 @@ var AttributeApplicationValidator = class {
           return;
         }
         if (item.target.ref.$container !== attr.$container && isDelegateModel(item.target.ref.$container)) {
-          accept("error", `Cannot use fields inherited from a polymorphic base model in \`@@unique\``, {
+          accept("error", `Cannot use fields inherited from a polymorphic base model in \`${attrName}\``, {
             node: item
           });
         }
@@ -5775,15 +5953,6 @@ var AttributeApplicationValidator = class {
       });
     }
   }
-  rejectEncryptedFields(attr, accept) {
-    import_langium3.AstUtils.streamAllContents(attr).forEach((node) => {
-      if (isDataFieldReference(node) && hasAttribute(node.target.ref, "@encrypted")) {
-        accept("error", `Encrypted fields cannot be used in policy rules`, {
-          node
-        });
-      }
-    });
-  }
   validatePolicyKinds(kind, candidates, attr, accept) {
     const items = kind.split(",").map((x) => x.trim());
     items.forEach((item) => {
@@ -5826,15 +5995,16 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], AttributeApplicationValidator.prototype, "_checkValidate", null);
 _ts_decorate([
-  check("@@unique"),
   check("@@id"),
+  check("@@index"),
+  check("@@unique"),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
     typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
   ]),
   _ts_metadata("design:returntype", void 0)
-], AttributeApplicationValidator.prototype, "_checkUnique", null);
+], AttributeApplicationValidator.prototype, "_checkConstraint", null);
 function assignableToAttributeParam(arg, param, attr) {
   const argResolvedType = arg.$resolvedType;
   if (!argResolvedType) {
@@ -5844,6 +6014,10 @@ function assignableToAttributeParam(arg, param, attr) {
   let dstIsArray = param.type.array;
   if (dstType === "ContextType") {
     if (isDataField(attr.$container)) {
+      const dstIsTypedJson = hasAttribute(attr.$container, "@json");
+      if (dstIsTypedJson && attr.decl.ref?.name === "@default") {
+        return argResolvedType.decl === "String";
+      }
       dstIsArray = attr.$container.type.array;
     }
   }
@@ -5935,6 +6109,9 @@ function isValidAttributeTarget(attrDecl, targetDecl) {
       case "TypeDefField":
         allowed = allowed || isTypeDef(targetDecl.type.reference?.ref);
         break;
+      case "ListField":
+        allowed = allowed || !isDataModel(targetDecl.type.reference?.ref) && targetDecl.type.array;
+        break;
       default:
         break;
     }
@@ -5961,7 +6138,7 @@ var AttributeValidator = class {
 };
 
 // src/validators/datamodel-validator.ts
-var import_common_helpers2 = require("@zenstackhq/common-helpers");
+var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_langium4 = require("langium");
 
 // src/validators/common.ts
@@ -6332,7 +6509,7 @@ var DataModelValidator = class {
     if (!model.baseModel) {
       return;
     }
-    (0, import_common_helpers2.invariant)(model.baseModel.ref, "baseModel must be resolved");
+    (0, import_common_helpers.invariant)(model.baseModel.ref, "baseModel must be resolved");
     if (!isDelegateModel(model.baseModel.ref)) {
       accept("error", `Model ${model.baseModel.$refText} cannot be extended because it's not a delegate model`, {
         node: model,
@@ -6354,7 +6531,7 @@ var DataModelValidator = class {
       }
       seen.push(current);
       if (current.baseModel) {
-        (0, import_common_helpers2.invariant)(current.baseModel.ref, "baseModel must be resolved");
+        (0, import_common_helpers.invariant)(current.baseModel.ref, "baseModel must be resolved");
         todo.push(current.baseModel.ref);
       }
     }
@@ -6484,11 +6661,21 @@ var ExpressionValidator = class {
       }
     }
     switch (expr.$type) {
+      case "MemberAccessExpr":
+        this.validateMemberAccessExpr(expr, accept);
+        break;
       case "BinaryExpr":
         this.validateBinaryExpr(expr, accept);
         break;
     }
   }
+  validateMemberAccessExpr(expr, accept) {
+    if (isBeforeInvocation(expr.operand) && isDataModel(expr.$resolvedType?.decl)) {
+      accept("error", "relation fields cannot be accessed from `before()`", {
+        node: expr
+      });
+    }
+  }
   validateBinaryExpr(expr, accept) {
     switch (expr.operator) {
       case "in": {
@@ -6541,23 +6728,25 @@ var ExpressionValidator = class {
             "Any"
           ];
         }
-        if (typeof expr.left.$resolvedType?.decl !== "string" || !supportedShapes.includes(expr.left.$resolvedType.decl)) {
+        const leftResolvedDecl = expr.left.$resolvedType?.decl;
+        const rightResolvedDecl = expr.right.$resolvedType?.decl;
+        if (leftResolvedDecl && (typeof leftResolvedDecl !== "string" || !supportedShapes.includes(leftResolvedDecl))) {
           accept("error", `invalid operand type for "${expr.operator}" operator`, {
             node: expr.left
           });
           return;
         }
-        if (typeof expr.right.$resolvedType?.decl !== "string" || !supportedShapes.includes(expr.right.$resolvedType.decl)) {
+        if (rightResolvedDecl && (typeof rightResolvedDecl !== "string" || !supportedShapes.includes(rightResolvedDecl))) {
           accept("error", `invalid operand type for "${expr.operator}" operator`, {
             node: expr.right
           });
           return;
         }
-        if (expr.left.$resolvedType.decl === "DateTime" && expr.right.$resolvedType.decl !== "DateTime") {
+        if (leftResolvedDecl === "DateTime" && rightResolvedDecl && rightResolvedDecl !== "DateTime") {
           accept("error", "incompatible operand types", {
             node: expr
           });
-        } else if (expr.right.$resolvedType.decl === "DateTime" && expr.left.$resolvedType.decl !== "DateTime") {
+        } else if (rightResolvedDecl === "DateTime" && leftResolvedDecl && leftResolvedDecl !== "DateTime") {
           accept("error", "incompatible operand types", {
             node: expr
           });
@@ -6597,11 +6786,11 @@ var ExpressionValidator = class {
             });
           }
           if (isDataFieldReference(expr.left) && (isThisExpr(expr.right) || isDataFieldReference(expr.right))) {
-            accept("error", "comparison between model-typed fields are not supported", {
+            accept("error", "comparison between models is not supported", {
               node: expr
             });
           } else if (isDataFieldReference(expr.right) && (isThisExpr(expr.left) || isDataFieldReference(expr.left))) {
-            accept("error", "comparison between model-typed fields are not supported", {
+            accept("error", "comparison between models is not supported", {
               node: expr
             });
           }
@@ -6691,41 +6880,39 @@ var FunctionInvocationValidator = class {
     if (!this.validateArgs(funcDecl, expr.args, accept)) {
       return;
     }
-    if (isFromStdlib(funcDecl)) {
-      let curr = expr.$container;
-      let containerAttribute;
-      while (curr) {
-        if (isDataModelAttribute(curr) || isDataFieldAttribute(curr)) {
-          containerAttribute = curr;
-          break;
-        }
-        curr = curr.$container;
+    let curr = expr.$container;
+    let containerAttribute;
+    while (curr) {
+      if (isDataModelAttribute(curr) || isDataFieldAttribute(curr)) {
+        containerAttribute = curr;
+        break;
       }
-      const exprContext = (0, import_ts_pattern.match)(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(import_ts_pattern.P.union("@@allow", "@@deny", "@allow", "@deny"), () => ExpressionContext.AccessPolicy).with("@@validate", () => ExpressionContext.ValidationRule).with("@@index", () => ExpressionContext.Index).otherwise(() => void 0);
-      const funcAllowedContext = getFunctionExpressionContext(funcDecl);
-      if (exprContext && !funcAllowedContext.includes(exprContext)) {
-        accept("error", `function "${funcDecl.name}" is not allowed in the current context: ${exprContext}`, {
-          node: expr
+      curr = curr.$container;
+    }
+    const exprContext = this.getExpressionContext(containerAttribute);
+    const funcAllowedContext = getFunctionExpressionContext(funcDecl);
+    if (exprContext && !funcAllowedContext.includes(exprContext)) {
+      accept("error", `function "${funcDecl.name}" is not allowed in the current context: ${exprContext}`, {
+        node: expr
+      });
+      return;
+    }
+    const allCasing = [
+      "original",
+      "upper",
+      "lower",
+      "capitalize",
+      "uncapitalize"
+    ];
+    if ([
+      "currentModel",
+      "currentOperation"
+    ].includes(funcDecl.name)) {
+      const arg = getLiteral(expr.args[0]?.value);
+      if (arg && !allCasing.includes(arg)) {
+        accept("error", `argument must be one of: ${allCasing.map((c) => '"' + c + '"').join(", ")}`, {
+          node: expr.args[0]
         });
-        return;
-      }
-      const allCasing = [
-        "original",
-        "upper",
-        "lower",
-        "capitalize",
-        "uncapitalize"
-      ];
-      if ([
-        "currentModel",
-        "currentOperation"
-      ].includes(funcDecl.name)) {
-        const arg = getLiteral(expr.args[0]?.value);
-        if (arg && !allCasing.includes(arg)) {
-          accept("error", `argument must be one of: ${allCasing.map((c) => '"' + c + '"').join(", ")}`, {
-            node: expr.args[0]
-          });
-        }
       }
     }
     const checker = invocationCheckers.get(expr.function.$refText);
@@ -6733,6 +6920,18 @@ var FunctionInvocationValidator = class {
       checker.value.call(this, expr, accept);
     }
   }
+  getExpressionContext(containerAttribute) {
+    if (!containerAttribute) {
+      return void 0;
+    }
+    if (this.isValidationAttribute(containerAttribute)) {
+      return ExpressionContext.ValidationRule;
+    }
+    return (0, import_ts_pattern.match)(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(import_ts_pattern.P.union("@@allow", "@@deny", "@allow", "@deny"), () => ExpressionContext.AccessPolicy).with("@@index", () => ExpressionContext.Index).otherwise(() => void 0);
+  }
+  isValidationAttribute(attr) {
+    return !!attr.decl.ref?.attributes.some((attr2) => attr2.decl.$refText === "@@@validation");
+  }
   validateArgs(funcDecl, args, accept) {
     let success = true;
     for (let i = 0; i < funcDecl.params.length; i++) {
@@ -6793,6 +6992,44 @@ var FunctionInvocationValidator = class {
     }
     return true;
   }
+  _checkLength(expr, accept) {
+    const msg = "argument must be a string or list field";
+    const fieldArg = expr.args[0].value;
+    if (!isDataFieldReference(fieldArg)) {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+      return;
+    }
+    if (isDataModel(fieldArg.$resolvedType?.decl)) {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+      return;
+    }
+    if (!fieldArg.$resolvedType?.array && fieldArg.$resolvedType?.decl !== "String") {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+    }
+  }
+  _checkRegex(expr, accept) {
+    const regex = expr.args[1]?.value;
+    if (!isStringLiteral(regex)) {
+      accept("error", "second argument must be a string literal", {
+        node: expr.args[1]
+      });
+      return;
+    }
+    try {
+      new RegExp(regex.value);
+    } catch (e) {
+      accept("error", "invalid regular expression: " + e.message, {
+        node: expr.args[1]
+      });
+    }
+  }
+  // TODO: move this to policy plugin
   _checkCheck(expr, accept) {
     let valid = true;
     const fieldArg = expr.args[0].value;
@@ -6864,6 +7101,24 @@ var FunctionInvocationValidator = class {
     }
   }
 };
+_ts_decorate2([
+  func("length"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkLength", null);
+_ts_decorate2([
+  func("regex"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkRegex", null);
 _ts_decorate2([
   func("check"),
   _ts_metadata2("design:type", Function),
@@ -6973,51 +7228,1040 @@ var ZModelValidator = class {
   constructor(services) {
     this.services = services;
   }
-  shouldCheck(node) {
-    let doc;
-    let currNode = node;
-    while (currNode) {
-      if (currNode.$document) {
-        doc = currNode.$document;
-        break;
-      }
-      currNode = currNode.$container;
-    }
-    return doc?.parseResult.lexerErrors.length === 0 && doc?.parseResult.parserErrors.length === 0;
-  }
   checkModel(node, accept) {
-    this.shouldCheck(node) && new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
+    new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
   }
   checkDataSource(node, accept) {
-    this.shouldCheck(node) && new DataSourceValidator().validate(node, accept);
+    new DataSourceValidator().validate(node, accept);
   }
   checkDataModel(node, accept) {
-    this.shouldCheck(node) && new DataModelValidator().validate(node, accept);
+    new DataModelValidator().validate(node, accept);
   }
   checkTypeDef(node, accept) {
-    this.shouldCheck(node) && new TypeDefValidator().validate(node, accept);
+    new TypeDefValidator().validate(node, accept);
   }
   checkEnum(node, accept) {
-    this.shouldCheck(node) && new EnumValidator().validate(node, accept);
+    new EnumValidator().validate(node, accept);
   }
   checkAttribute(node, accept) {
-    this.shouldCheck(node) && new AttributeValidator().validate(node, accept);
+    new AttributeValidator().validate(node, accept);
   }
   checkExpression(node, accept) {
-    this.shouldCheck(node) && new ExpressionValidator().validate(node, accept);
+    new ExpressionValidator().validate(node, accept);
   }
   checkFunctionInvocation(node, accept) {
-    this.shouldCheck(node) && new FunctionInvocationValidator().validate(node, accept);
+    new FunctionInvocationValidator().validate(node, accept);
   }
   checkFunctionDecl(node, accept) {
-    this.shouldCheck(node) && new FunctionDeclValidator().validate(node, accept);
+    new FunctionDeclValidator().validate(node, accept);
   }
 };
 
-// src/zmodel-linker.ts
+// src/zmodel-comment-provider.ts
 var import_langium7 = require("langium");
 var import_ts_pattern2 = require("ts-pattern");
-var ZModelLinker = class extends import_langium7.DefaultLinker {
+var ZModelCommentProvider = class extends import_langium7.DefaultCommentProvider {
+  static {
+    __name(this, "ZModelCommentProvider");
+  }
+  getComment(node) {
+    let comment = super.getComment(node);
+    if (!comment) {
+      comment = (0, import_ts_pattern2.match)(node).when(isDataModel, (d) => `/**
+ * Model *${d.name}*
+ */`).when(isTypeDef, (d) => `/**
+ * Type *${d.name}*
+ */`).when(isEnum, (e) => `/**
+ * Enum *${e.name}*
+ */`).when(isEnumField, (f) => `/**
+ * Value of enum *${f.$container?.name}*
+ */`).when(isDataField, (f) => `/**
+ * Field of *${f.$container?.name}*
+ */`).when(isFunctionDecl, (f) => `/**
+ * Function *${f.name}*
+ */`).otherwise(() => "");
+    }
+    return comment;
+  }
+};
+
+// src/zmodel-completion-provider.ts
+var import_lsp = require("langium/lsp");
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_ts_pattern3 = require("ts-pattern");
+var import_vscode_languageserver = require("vscode-languageserver");
+
+// src/zmodel-code-generator.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var generationHandlers = /* @__PURE__ */ new Map();
+function gen(name) {
+  return function(_target, _propertyKey, descriptor) {
+    if (!generationHandlers.get(name)) {
+      generationHandlers.set(name, descriptor);
+    }
+    return descriptor;
+  };
+}
+__name(gen, "gen");
+var ZModelCodeGenerator = class {
+  static {
+    __name(this, "ZModelCodeGenerator");
+  }
+  options;
+  constructor(options) {
+    this.options = {
+      binaryExprNumberOfSpaces: options?.binaryExprNumberOfSpaces ?? 1,
+      unaryExprNumberOfSpaces: options?.unaryExprNumberOfSpaces ?? 0,
+      indent: options?.indent ?? 4,
+      quote: options?.quote ?? "single"
+    };
+  }
+  /**
+   * Generates ZModel source code from AST.
+   */
+  generate(ast) {
+    const handler = generationHandlers.get(ast.$type);
+    if (!handler) {
+      throw new Error(`No generation handler found for ${ast.$type}`);
+    }
+    return handler.value.call(this, ast);
+  }
+  _generateModel(ast) {
+    return ast.declarations.map((d) => this.generate(d)).join("\n\n");
+  }
+  _generateDataSource(ast) {
+    return `datasource ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generateEnum(ast) {
+    return `enum ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generateEnumField(ast) {
+    return `${ast.name}${ast.attributes.length > 0 ? " " + ast.attributes.map((x) => this.generate(x)).join(" ") : ""}`;
+  }
+  _generateGenerator(ast) {
+    return `generator ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generateConfigField(ast) {
+    return `${ast.name} = ${this.generate(ast.value)}`;
+  }
+  _generateConfigArrayExpr(ast) {
+    return `[${ast.items.map((x) => this.generate(x)).join(", ")}]`;
+  }
+  _generateConfigInvocationExpr(ast) {
+    if (ast.args.length === 0) {
+      return ast.name;
+    } else {
+      return `${ast.name}(${ast.args.map((x) => (x.name ? x.name + ": " : "") + this.generate(x.value)).join(", ")})`;
+    }
+  }
+  _generatePlugin(ast) {
+    return `plugin ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generatePluginField(ast) {
+    return `${ast.name} = ${this.generate(ast.value)}`;
+  }
+  _generateDataModel(ast) {
+    return `${ast.isView ? "view" : "model"} ${ast.name}${ast.mixins.length > 0 ? " mixes " + ast.mixins.map((x) => x.ref?.name).join(", ") : ""} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}${ast.attributes.length > 0 ? "\n\n" + ast.attributes.map((x) => this.indent + this.generate(x)).join("\n") : ""}
+}`;
+  }
+  _generateDataField(ast) {
+    return `${ast.name} ${this.fieldType(ast.type)}${ast.attributes.length > 0 ? " " + ast.attributes.map((x) => this.generate(x)).join(" ") : ""}`;
+  }
+  fieldType(type) {
+    const baseType = type.type ? type.type : type.$type == "DataFieldType" && type.unsupported ? "Unsupported(" + this.generate(type.unsupported.value) + ")" : type.reference?.$refText;
+    return `${baseType}${type.array ? "[]" : ""}${type.optional ? "?" : ""}`;
+  }
+  _generateDataModelAttribute(ast) {
+    return this.attribute(ast);
+  }
+  _generateDataFieldAttribute(ast) {
+    return this.attribute(ast);
+  }
+  attribute(ast) {
+    const args = ast.args.length ? `(${ast.args.map((x) => this.generate(x)).join(", ")})` : "";
+    return `${resolved(ast.decl).name}${args}`;
+  }
+  _generateAttributeArg(ast) {
+    if (ast.name) {
+      return `${ast.name}: ${this.generate(ast.value)}`;
+    } else {
+      return this.generate(ast.value);
+    }
+  }
+  _generateObjectExpr(ast) {
+    return `{ ${ast.fields.map((field) => this.objectField(field)).join(", ")} }`;
+  }
+  objectField(field) {
+    return `${field.name}: ${this.generate(field.value)}`;
+  }
+  _generateArrayExpr(ast) {
+    return `[${ast.items.map((item) => this.generate(item)).join(", ")}]`;
+  }
+  _generateLiteralExpr(ast) {
+    return this.options.quote === "single" ? `'${ast.value}'` : `"${ast.value}"`;
+  }
+  _generateNumberLiteral(ast) {
+    return ast.value.toString();
+  }
+  _generateBooleanLiteral(ast) {
+    return ast.value.toString();
+  }
+  _generateUnaryExpr(ast) {
+    return `${ast.operator}${this.unaryExprSpace}${this.generate(ast.operand)}`;
+  }
+  _generateBinaryExpr(ast) {
+    const operator = ast.operator;
+    const isCollectionPredicate2 = this.isCollectionPredicateOperator(operator);
+    const rightExpr = this.generate(ast.right);
+    const { left: isLeftParenthesis, right: isRightParenthesis } = this.isParenthesesNeededForBinaryExpr(ast);
+    return `${isLeftParenthesis ? "(" : ""}${this.generate(ast.left)}${isLeftParenthesis ? ")" : ""}${isCollectionPredicate2 ? "" : this.binaryExprSpace}${operator}${isCollectionPredicate2 ? "" : this.binaryExprSpace}${isRightParenthesis ? "(" : ""}${isCollectionPredicate2 ? `[${rightExpr}]` : rightExpr}${isRightParenthesis ? ")" : ""}`;
+  }
+  _generateReferenceExpr(ast) {
+    const args = ast.args.length ? `(${ast.args.map((x) => this.generate(x)).join(", ")})` : "";
+    return `${ast.target.ref?.name}${args}`;
+  }
+  _generateReferenceArg(ast) {
+    return `${ast.name}:${this.generate(ast.value)}`;
+  }
+  _generateMemberExpr(ast) {
+    return `${this.generate(ast.operand)}.${ast.member.ref?.name}`;
+  }
+  _generateInvocationExpr(ast) {
+    return `${ast.function.ref?.name}(${ast.args.map((x) => this.argument(x)).join(", ")})`;
+  }
+  _generateNullExpr() {
+    return "null";
+  }
+  _generateThisExpr() {
+    return "this";
+  }
+  _generateAttribute(ast) {
+    return `attribute ${ast.name}(${ast.params.map((x) => this.generate(x)).join(", ")})`;
+  }
+  _generateAttributeParam(ast) {
+    return `${ast.default ? "_ " : ""}${ast.name}: ${this.generate(ast.type)}`;
+  }
+  _generateAttributeParamType(ast) {
+    return `${ast.type ?? ast.reference?.$refText}${ast.array ? "[]" : ""}${ast.optional ? "?" : ""}`;
+  }
+  _generateFunctionDecl(ast) {
+    return `function ${ast.name}(${ast.params.map((x) => this.generate(x)).join(", ")}) ${ast.returnType ? ": " + this.generate(ast.returnType) : ""} {}`;
+  }
+  _generateFunctionParam(ast) {
+    return `${ast.name}: ${this.generate(ast.type)}`;
+  }
+  _generateFunctionParamType(ast) {
+    return `${ast.type ?? ast.reference?.$refText}${ast.array ? "[]" : ""}`;
+  }
+  _generateTypeDef(ast) {
+    return `type ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}${ast.attributes.length > 0 ? "\n\n" + ast.attributes.map((x) => this.indent + this.generate(x)).join("\n") : ""}
+}`;
+  }
+  argument(ast) {
+    return this.generate(ast.value);
+  }
+  get binaryExprSpace() {
+    return " ".repeat(this.options.binaryExprNumberOfSpaces);
+  }
+  get unaryExprSpace() {
+    return " ".repeat(this.options.unaryExprNumberOfSpaces);
+  }
+  get indent() {
+    return " ".repeat(this.options.indent);
+  }
+  isParenthesesNeededForBinaryExpr(ast) {
+    const result = {
+      left: false,
+      right: false
+    };
+    const operator = ast.operator;
+    const isCollectionPredicate2 = this.isCollectionPredicateOperator(operator);
+    const currentPriority = BinaryExprOperatorPriority[operator];
+    if (ast.left.$type === BinaryExpr && BinaryExprOperatorPriority[ast.left["operator"]] < currentPriority) {
+      result.left = true;
+    }
+    if (!isCollectionPredicate2 && ast.right.$type === BinaryExpr && BinaryExprOperatorPriority[ast.right["operator"]] <= currentPriority) {
+      result.right = true;
+    }
+    return result;
+  }
+  isCollectionPredicateOperator(op) {
+    return [
+      "?",
+      "!",
+      "^"
+    ].includes(op);
+  }
+};
+_ts_decorate3([
+  gen(Model),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Model === "undefined" ? Object : Model
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateModel", null);
+_ts_decorate3([
+  gen(DataSource),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataSource === "undefined" ? Object : DataSource
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataSource", null);
+_ts_decorate3([
+  gen(Enum),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Enum === "undefined" ? Object : Enum
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnum", null);
+_ts_decorate3([
+  gen(EnumField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof EnumField === "undefined" ? Object : EnumField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnumField", null);
+_ts_decorate3([
+  gen(GeneratorDecl),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof GeneratorDecl === "undefined" ? Object : GeneratorDecl
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateGenerator", null);
+_ts_decorate3([
+  gen(ConfigField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ConfigField === "undefined" ? Object : ConfigField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigField", null);
+_ts_decorate3([
+  gen(ConfigArrayExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ConfigArrayExpr === "undefined" ? Object : ConfigArrayExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigArrayExpr", null);
+_ts_decorate3([
+  gen(ConfigInvocationExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ConfigInvocationExpr === "undefined" ? Object : ConfigInvocationExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigInvocationExpr", null);
+_ts_decorate3([
+  gen(Plugin),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Plugin === "undefined" ? Object : Plugin
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePlugin", null);
+_ts_decorate3([
+  gen(PluginField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof PluginField === "undefined" ? Object : PluginField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePluginField", null);
+_ts_decorate3([
+  gen(DataModel),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataModel === "undefined" ? Object : DataModel
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModel", null);
+_ts_decorate3([
+  gen(DataField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataField === "undefined" ? Object : DataField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataField", null);
+_ts_decorate3([
+  gen(DataModelAttribute),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataModelAttribute === "undefined" ? Object : DataModelAttribute
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
+_ts_decorate3([
+  gen(DataFieldAttribute),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataFieldAttribute === "undefined" ? Object : DataFieldAttribute
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataFieldAttribute", null);
+_ts_decorate3([
+  gen(AttributeArg),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AttributeArg === "undefined" ? Object : AttributeArg
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeArg", null);
+_ts_decorate3([
+  gen(ObjectExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ObjectExpr === "undefined" ? Object : ObjectExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateObjectExpr", null);
+_ts_decorate3([
+  gen(ArrayExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ArrayExpr === "undefined" ? Object : ArrayExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateArrayExpr", null);
+_ts_decorate3([
+  gen(StringLiteral),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof LiteralExpr === "undefined" ? Object : LiteralExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateLiteralExpr", null);
+_ts_decorate3([
+  gen(NumberLiteral),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof NumberLiteral === "undefined" ? Object : NumberLiteral
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNumberLiteral", null);
+_ts_decorate3([
+  gen(BooleanLiteral),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof BooleanLiteral === "undefined" ? Object : BooleanLiteral
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBooleanLiteral", null);
+_ts_decorate3([
+  gen(UnaryExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof UnaryExpr === "undefined" ? Object : UnaryExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateUnaryExpr", null);
+_ts_decorate3([
+  gen(BinaryExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof BinaryExpr === "undefined" ? Object : BinaryExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBinaryExpr", null);
+_ts_decorate3([
+  gen(ReferenceExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ReferenceExpr === "undefined" ? Object : ReferenceExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceExpr", null);
+_ts_decorate3([
+  gen(ReferenceArg),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ReferenceArg === "undefined" ? Object : ReferenceArg
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceArg", null);
+_ts_decorate3([
+  gen(MemberAccessExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof MemberAccessExpr === "undefined" ? Object : MemberAccessExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateMemberExpr", null);
+_ts_decorate3([
+  gen(InvocationExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateInvocationExpr", null);
+_ts_decorate3([
+  gen(NullExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNullExpr", null);
+_ts_decorate3([
+  gen(ThisExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateThisExpr", null);
+_ts_decorate3([
+  gen(Attribute),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Attribute === "undefined" ? Object : Attribute
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttribute", null);
+_ts_decorate3([
+  gen(AttributeParam),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AttributeParam === "undefined" ? Object : AttributeParam
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParam", null);
+_ts_decorate3([
+  gen(AttributeParamType),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AttributeParamType === "undefined" ? Object : AttributeParamType
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParamType", null);
+_ts_decorate3([
+  gen(FunctionDecl),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof FunctionDecl === "undefined" ? Object : FunctionDecl
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionDecl", null);
+_ts_decorate3([
+  gen(FunctionParam),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof FunctionParam === "undefined" ? Object : FunctionParam
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParam", null);
+_ts_decorate3([
+  gen(FunctionParamType),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof FunctionParamType === "undefined" ? Object : FunctionParamType
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParamType", null);
+_ts_decorate3([
+  gen(TypeDef),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof TypeDef === "undefined" ? Object : TypeDef
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
+
+// src/zmodel-completion-provider.ts
+var ZModelCompletionProvider = class extends import_lsp.DefaultCompletionProvider {
+  static {
+    __name(this, "ZModelCompletionProvider");
+  }
+  services;
+  constructor(services) {
+    super(services), this.services = services;
+  }
+  completionOptions = {
+    triggerCharacters: [
+      "@",
+      "(",
+      ",",
+      "."
+    ]
+  };
+  async getCompletion(document, params) {
+    try {
+      return await super.getCompletion(document, params);
+    } catch (e) {
+      console.error("Completion error:", e.message);
+      return void 0;
+    }
+  }
+  completionFor(context, next, acceptor) {
+    if (isDataModelAttribute(context.node) || isDataFieldAttribute(context.node)) {
+      const completions = this.getCompletionFromHint(context.node);
+      if (completions) {
+        completions.forEach((c) => acceptor(context, c));
+        return;
+      }
+    }
+    return super.completionFor(context, next, acceptor);
+  }
+  getCompletionFromHint(contextNode) {
+    const unfilledParams = this.getUnfilledAttributeParams(contextNode);
+    const nextParam = unfilledParams[0];
+    if (!nextParam) {
+      return void 0;
+    }
+    const hintAttr = getAttribute(nextParam, "@@@completionHint");
+    if (hintAttr) {
+      const hint = hintAttr.args[0];
+      if (hint?.value) {
+        if (isArrayExpr(hint.value)) {
+          return hint.value.items.map((item) => {
+            return {
+              label: `${item.value}`,
+              kind: import_vscode_languageserver.CompletionItemKind.Value,
+              detail: "Parameter",
+              sortText: "0"
+            };
+          });
+        }
+      }
+    }
+    return void 0;
+  }
+  // TODO: this doesn't work when the file contains parse errors
+  getUnfilledAttributeParams(contextNode) {
+    try {
+      const params = contextNode.decl.ref?.params;
+      if (params) {
+        const args = contextNode.args;
+        let unfilledParams = [
+          ...params
+        ];
+        args.forEach((arg) => {
+          if (arg.name) {
+            unfilledParams = unfilledParams.filter((p) => p.name !== arg.name);
+          } else {
+            unfilledParams.shift();
+          }
+        });
+        return unfilledParams;
+      }
+    } catch {
+    }
+    return [];
+  }
+  completionForCrossReference(context, crossRef, acceptor) {
+    if (crossRef.property === "member" && !isMemberAccessExpr(context.node)) {
+      return;
+    }
+    const customAcceptor = /* @__PURE__ */ __name((context2, item) => {
+      if (item.insertText?.startsWith("@@@") || item.label?.startsWith("@@@")) {
+        return;
+      }
+      if ("nodeDescription" in item) {
+        const node = this.getAstNode(item.nodeDescription);
+        if (!node) {
+          return;
+        }
+        if ((isEnum(node) || isEnumField(node)) && isFromStdlib(node)) {
+          return;
+        }
+        if ((isDataModelAttribute(context2.node) || isDataFieldAttribute(context2.node)) && !this.filterAttributeApplicationCompletion(context2.node, node)) {
+          return;
+        }
+      }
+      acceptor(context2, item);
+    }, "customAcceptor");
+    return super.completionForCrossReference(context, crossRef, customAcceptor);
+  }
+  completionForKeyword(context, keyword, acceptor) {
+    const customAcceptor = /* @__PURE__ */ __name((context2, item) => {
+      if (!this.filterKeywordForContext(context2, keyword.value)) {
+        return;
+      }
+      acceptor(context2, item);
+    }, "customAcceptor");
+    return super.completionForKeyword(context, keyword, customAcceptor);
+  }
+  filterKeywordForContext(context, keyword) {
+    if (isInvocationExpr(context.node)) {
+      return [
+        "true",
+        "false",
+        "null",
+        "this"
+      ].includes(keyword);
+    } else if (isDataModelAttribute(context.node) || isDataFieldAttribute(context.node)) {
+      const exprContext = this.getAttributeContextType(context.node);
+      if (exprContext === "DefaultValue") {
+        return [
+          "true",
+          "false",
+          "null"
+        ].includes(keyword);
+      } else {
+        return [
+          "true",
+          "false",
+          "null",
+          "this"
+        ].includes(keyword);
+      }
+    } else {
+      return true;
+    }
+  }
+  filterAttributeApplicationCompletion(contextNode, node) {
+    const attrContextType = this.getAttributeContextType(contextNode);
+    if (isFunctionDecl(node) && attrContextType) {
+      const funcExprContextAttr = getAttribute(node, "@@@expressionContext");
+      if (funcExprContextAttr && funcExprContextAttr.args[0]) {
+        const arg = funcExprContextAttr.args[0];
+        if (isArrayExpr(arg.value)) {
+          return arg.value.items.some((item) => isEnumFieldReference(item) && item.target.$refText === attrContextType);
+        }
+      }
+      return false;
+    }
+    if (isDataField(node)) {
+      return attrContextType !== "DefaultValue";
+    }
+    return true;
+  }
+  getAttributeContextType(node) {
+    return (0, import_ts_pattern3.match)(node.decl.$refText).with("@default", () => "DefaultValue").with(import_ts_pattern3.P.union("@@allow", "@allow", "@@deny", "@deny"), () => "AccessPolicy").with("@@validate", () => "ValidationRule").otherwise(() => void 0);
+  }
+  createReferenceCompletionItem(nodeDescription) {
+    const node = this.getAstNode(nodeDescription);
+    const documentation = this.getNodeDocumentation(node);
+    return (0, import_ts_pattern3.match)(node).when(isDataModel, () => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Class,
+      detail: "Model",
+      sortText: "1",
+      documentation
+    })).when(isTypeDef, () => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Class,
+      detail: "Type",
+      sortText: "1",
+      documentation
+    })).when(isDataField, () => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Field,
+      detail: "Field",
+      sortText: "0",
+      documentation
+    })).when(isEnum, () => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Class,
+      detail: "Enum",
+      sortText: "1",
+      documentation
+    })).when(isEnumField, (d) => {
+      const container = d.$container;
+      return {
+        nodeDescription,
+        kind: import_vscode_languageserver.CompletionItemKind.Enum,
+        detail: `Value of enum "${container.name}"`,
+        sortText: "1",
+        documentation
+      };
+    }).when(isFunctionDecl, () => ({
+      nodeDescription,
+      insertText: this.getFunctionInsertText(nodeDescription),
+      kind: import_vscode_languageserver.CompletionItemKind.Function,
+      detail: "Function",
+      sortText: "1",
+      documentation
+    })).when(isAttribute, () => ({
+      nodeDescription,
+      insertText: this.getAttributeInsertText(nodeDescription),
+      kind: import_vscode_languageserver.CompletionItemKind.Property,
+      detail: "Attribute",
+      sortText: "1",
+      documentation
+    })).otherwise(() => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Reference,
+      detail: nodeDescription.type,
+      sortText: "2",
+      documentation
+    }));
+  }
+  getFunctionInsertText(nodeDescription) {
+    const node = this.getAstNode(nodeDescription);
+    if (isFunctionDecl(node)) {
+      if (node.params.some((p) => !p.optional)) {
+        return nodeDescription.name;
+      }
+    }
+    return `${nodeDescription.name}()`;
+  }
+  getAttributeInsertText(nodeDescription) {
+    const node = this.getAstNode(nodeDescription);
+    if (isAttribute(node)) {
+      if (node.name === "@relation") {
+        return `${nodeDescription.name}(fields: [], references: [])`;
+      }
+    }
+    return nodeDescription.name;
+  }
+  getAstNode(nodeDescription) {
+    let node = nodeDescription.node;
+    if (!node) {
+      const doc = this.getOrCreateDocumentSync(nodeDescription);
+      if (!doc) {
+        return void 0;
+      }
+      node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);
+      if (!node) {
+        return void 0;
+      }
+    }
+    return node;
+  }
+  getOrCreateDocumentSync(nodeDescription) {
+    let doc = this.services.shared.workspace.LangiumDocuments.getDocument(nodeDescription.documentUri);
+    if (!doc) {
+      try {
+        const content = import_node_fs2.default.readFileSync(nodeDescription.documentUri.fsPath, "utf-8");
+        doc = this.services.shared.workspace.LangiumDocuments.createDocument(nodeDescription.documentUri, content);
+      } catch {
+        console.warn("Failed to read or create document:", nodeDescription.documentUri);
+        return void 0;
+      }
+    }
+    return doc;
+  }
+  getNodeDocumentation(node) {
+    if (!node) {
+      return void 0;
+    }
+    const md = this.commentsToMarkdown(node);
+    return {
+      kind: "markdown",
+      value: md
+    };
+  }
+  commentsToMarkdown(node) {
+    const md = this.services.documentation.DocumentationProvider.getDocumentation(node) ?? "";
+    const zModelGenerator = new ZModelCodeGenerator();
+    const docs = [];
+    try {
+      (0, import_ts_pattern3.match)(node).when(isAttribute, (attr) => {
+        docs.push("```prisma", zModelGenerator.generate(attr), "```");
+      }).when(isFunctionDecl, (func2) => {
+        docs.push("```ts", zModelGenerator.generate(func2), "```");
+      }).when(isDataModel, (model) => {
+        docs.push("```prisma", `model ${model.name} { ... }`, "```");
+      }).when(isEnum, (enumDecl) => {
+        docs.push("```prisma", zModelGenerator.generate(enumDecl), "```");
+      }).when(isDataField, (field) => {
+        docs.push(`${field.name}: ${field.type.type ?? field.type.reference?.$refText}`);
+      }).otherwise((ast) => {
+        const name = ast.name;
+        if (name) {
+          docs.push(name);
+        }
+      });
+    } catch {
+    }
+    if (md) {
+      docs.push("___", md);
+    }
+    return docs.join("\n");
+  }
+};
+
+// src/zmodel-definition.ts
+var import_lsp2 = require("langium/lsp");
+var import_vscode_languageserver2 = require("vscode-languageserver");
+var ZModelDefinitionProvider = class extends import_lsp2.DefaultDefinitionProvider {
+  static {
+    __name(this, "ZModelDefinitionProvider");
+  }
+  documents;
+  constructor(services) {
+    super(services);
+    this.documents = services.shared.workspace.LangiumDocuments;
+  }
+  collectLocationLinks(sourceCstNode, _params) {
+    if (isModelImport(sourceCstNode.astNode)) {
+      const importedModel = resolveImport(this.documents, sourceCstNode.astNode);
+      if (importedModel?.$document) {
+        const targetObject = importedModel;
+        const selectionRange = this.nameProvider.getNameNode(targetObject)?.range ?? import_vscode_languageserver2.Range.create(0, 0, 0, 0);
+        const previewRange = targetObject.$cstNode?.range ?? import_vscode_languageserver2.Range.create(0, 0, 0, 0);
+        return [
+          import_vscode_languageserver2.LocationLink.create(importedModel.$document.uri.toString(), previewRange, selectionRange, sourceCstNode.range)
+        ];
+      }
+      return void 0;
+    }
+    return super.collectLocationLinks(sourceCstNode, _params);
+  }
+};
+
+// src/zmodel-document-builder.ts
+var import_langium8 = require("langium");
+var ZModelDocumentBuilder = class extends import_langium8.DefaultDocumentBuilder {
+  static {
+    __name(this, "ZModelDocumentBuilder");
+  }
+  constructor(services) {
+    super(services);
+    let validationOptions = this.updateBuildOptions.validation;
+    const stopFlags = {
+      stopAfterLinkingErrors: true,
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true
+    };
+    if (validationOptions === true) {
+      validationOptions = stopFlags;
+    } else if (typeof validationOptions === "object") {
+      validationOptions = {
+        ...validationOptions,
+        ...stopFlags
+      };
+    }
+    this.updateBuildOptions = {
+      ...this.updateBuildOptions,
+      validation: validationOptions
+    };
+  }
+};
+
+// src/zmodel-documentation-provider.ts
+var import_langium9 = require("langium");
+var ZModelDocumentationProvider = class extends import_langium9.JSDocDocumentationProvider {
+  static {
+    __name(this, "ZModelDocumentationProvider");
+  }
+  getDocumentation(node) {
+    if ("comments" in node && Array.isArray(node.comments) && node.comments.length > 0) {
+      return node.comments.map((c) => c.replace(/^[/]*\s*/, "")).join("\n");
+    }
+    return super.getDocumentation(node);
+  }
+};
+
+// src/zmodel-formatter.ts
+var import_lsp3 = require("langium/lsp");
+var ZModelFormatter = class extends import_lsp3.AbstractFormatter {
+  static {
+    __name(this, "ZModelFormatter");
+  }
+  formatOptions;
+  configurationProvider;
+  constructor(services) {
+    super();
+    this.configurationProvider = services.shared.workspace.ConfigurationProvider;
+  }
+  format(node) {
+    const formatter = this.getNodeFormatter(node);
+    if (isDataField(node)) {
+      if (isDataModel(node.$container) || isTypeDef(node.$container)) {
+        const dataModel = node.$container;
+        const compareFn = /* @__PURE__ */ __name((a, b) => b - a, "compareFn");
+        const maxNameLength = dataModel.fields.map((x) => x.name.length).sort(compareFn)[0] ?? 0;
+        const maxTypeLength = dataModel.fields.map(this.getFieldTypeLength).sort(compareFn)[0] ?? 0;
+        formatter.property("type").prepend(import_lsp3.Formatting.spaces(maxNameLength - node.name.length + 1));
+        if (node.attributes.length > 0) {
+          formatter.node(node.attributes[0]).prepend(import_lsp3.Formatting.spaces(maxTypeLength - this.getFieldTypeLength(node) + 1));
+          formatter.nodes(...node.attributes.slice(1)).prepend(import_lsp3.Formatting.oneSpace());
+        }
+      } else {
+        formatter.property("type").prepend(import_lsp3.Formatting.oneSpace());
+        if (node.attributes.length > 0) {
+          formatter.properties("attributes").prepend(import_lsp3.Formatting.oneSpace());
+        }
+      }
+    } else if (isDataFieldAttribute(node)) {
+      formatter.keyword("(").surround(import_lsp3.Formatting.noSpace());
+      formatter.keyword(")").prepend(import_lsp3.Formatting.noSpace());
+      formatter.keyword(",").append(import_lsp3.Formatting.oneSpace());
+      if (node.args.length > 1) {
+        formatter.nodes(...node.args.slice(1)).prepend(import_lsp3.Formatting.oneSpace());
+      }
+    } else if (isAttributeArg(node)) {
+      formatter.keyword(":").prepend(import_lsp3.Formatting.noSpace());
+      formatter.keyword(":").append(import_lsp3.Formatting.oneSpace());
+    } else if (isAbstractDeclaration(node)) {
+      const bracesOpen = formatter.keyword("{");
+      const bracesClose = formatter.keyword("}");
+      formatter.interior(bracesOpen, bracesClose).prepend(import_lsp3.Formatting.indent({
+        allowMore: true
+      }));
+      bracesOpen.prepend(import_lsp3.Formatting.oneSpace());
+      bracesClose.prepend(import_lsp3.Formatting.newLine());
+    } else if (isModel(node)) {
+      const model = node;
+      const nodes = formatter.nodes(...model.declarations);
+      nodes.prepend(import_lsp3.Formatting.noIndent());
+    }
+  }
+  formatDocument(document, params) {
+    this.formatOptions = params.options;
+    this.configurationProvider.getConfiguration(ZModelLanguageMetaData.languageId, "format").then((config) => {
+      if (config) {
+      }
+    });
+    return super.formatDocument(document, params);
+  }
+  getFormatOptions() {
+    return this.formatOptions;
+  }
+  getIndent() {
+    return 1;
+  }
+  getFieldTypeLength(field) {
+    let length;
+    if (field.type.type) {
+      length = field.type.type.length;
+    } else if (field.type.reference) {
+      length = field.type.reference.$refText.length;
+    } else if (isDataField(field) && field.type.unsupported) {
+      const name = `Unsupported("${field.type.unsupported.value.value}")`;
+      length = name.length;
+    } else {
+      length = 1;
+    }
+    if (field.type.optional) {
+      length += 1;
+    }
+    if (field.type.array) {
+      length += 2;
+    }
+    return length;
+  }
+};
+
+// src/zmodel-linker.ts
+var import_langium10 = require("langium");
+var import_ts_pattern4 = require("ts-pattern");
+var ZModelLinker = class extends import_langium10.DefaultLinker {
   static {
     __name(this, "ZModelLinker");
   }
@@ -7027,31 +8271,29 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
     this.descriptions = services.workspace.AstNodeDescriptionProvider;
   }
   //#region Reference linking
-  async link(document, cancelToken = import_langium7.Cancellation.CancellationToken.None) {
+  async link(document, cancelToken = import_langium10.Cancellation.CancellationToken.None) {
     if (document.parseResult.lexerErrors?.length > 0 || document.parseResult.parserErrors?.length > 0) {
       return;
     }
-    for (const node of import_langium7.AstUtils.streamContents(document.parseResult.value)) {
-      await (0, import_langium7.interruptAndCheck)(cancelToken);
+    for (const node of import_langium10.AstUtils.streamContents(document.parseResult.value)) {
+      await (0, import_langium10.interruptAndCheck)(cancelToken);
       this.resolve(node, document);
     }
-    document.state = import_langium7.DocumentState.Linked;
+    document.state = import_langium10.DocumentState.Linked;
   }
-  linkReference(container, property, document, extraScopes) {
-    if (this.resolveFromScopeProviders(container, property, document, extraScopes)) {
+  linkReference(refInfo, document, extraScopes) {
+    const defaultRef = refInfo.reference;
+    if (defaultRef._ref) {
+      return;
+    }
+    if (this.resolveFromScopeProviders(refInfo.reference, document, extraScopes)) {
       return;
     }
-    const reference = container[property];
-    this.doLink({
-      reference,
-      container,
-      property
-    }, document);
+    this.doLink(refInfo, document);
   }
   //#endregion
   //#region Expression type resolving
-  resolveFromScopeProviders(node, property, document, providers) {
-    const reference = node[property];
+  resolveFromScopeProviders(reference, document, providers) {
     for (const provider of providers) {
       const target = provider(reference.$refText);
       if (target) {
@@ -7180,12 +8422,16 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
     }
   }
   resolveInvocation(node, document, extraScopes) {
-    this.linkReference(node, "function", document, extraScopes);
+    this.linkReference({
+      reference: node.function,
+      container: node,
+      property: "function"
+    }, document, extraScopes);
     node.args.forEach((arg) => this.resolve(arg, document, extraScopes));
     if (node.function.ref) {
       const funcDecl = node.function.ref;
       if (isAuthInvocation(node)) {
-        const allDecls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.langiumDocuments(), import_langium7.AstUtils.getContainerOfType(node, isDataModel));
+        const allDecls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.langiumDocuments(), import_langium10.AstUtils.getContainerOfType(node, isDataModel));
         const authDecl = getAuthDecl(allDecls);
         if (authDecl) {
           node.$resolvedType = {
@@ -7193,7 +8439,7 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
             nullable: true
           };
         }
-      } else if (isFutureExpr(node)) {
+      } else if (isBeforeInvocation(node)) {
         node.$resolvedType = {
           decl: getContainingDataModel(node)
         };
@@ -7203,7 +8449,7 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
     }
   }
   resolveLiteral(node) {
-    const type = (0, import_ts_pattern2.match)(node).when(isStringLiteral, () => "String").when(isBooleanLiteral, () => "Boolean").when(isNumberLiteral, () => "Int").exhaustive();
+    const type = (0, import_ts_pattern4.match)(node).when(isStringLiteral, () => "String").when(isBooleanLiteral, () => "Boolean").when(isNumberLiteral, () => "Int").exhaustive();
     if (type) {
       this.resolveToBuiltinTypeOrDecl(node, type);
     }
@@ -7257,7 +8503,7 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
         if (isArrayExpr(node.value)) {
           node.value.items.forEach((item) => {
             if (isReferenceExpr(item)) {
-              const resolved2 = this.resolveFromScopeProviders(item, "target", document, [
+              const resolved2 = this.resolveFromScopeProviders(item.target, document, [
                 scopeProvider
               ]);
               if (resolved2) {
@@ -7271,7 +8517,7 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
             this.resolveToBuiltinTypeOrDecl(node.value, node.value.items[0].$resolvedType.decl, true);
           }
         } else if (isReferenceExpr(node.value)) {
-          const resolved2 = this.resolveFromScopeProviders(node.value, "target", document, [
+          const resolved2 = this.resolveFromScopeProviders(node.value.target, document, [
             scopeProvider
           ]);
           if (resolved2) {
@@ -7323,14 +8569,10 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
     this.resolveDefault(node, document, scopes);
   }
   resolveDefault(node, document, extraScopes) {
-    for (const [property, value] of Object.entries(node)) {
-      if (!property.startsWith("$")) {
-        if ((0, import_langium7.isReference)(value)) {
-          this.linkReference(node, property, document, extraScopes);
-        }
-      }
-    }
-    for (const child of import_langium7.AstUtils.streamContents(node)) {
+    import_langium10.AstUtils.streamReferences(node).forEach((ref) => {
+      this.linkReference(ref, document, extraScopes);
+    });
+    for (const child of import_langium10.AstUtils.streamContents(node)) {
       this.resolve(child, document, extraScopes);
     }
   }
@@ -7374,9 +8616,9 @@ var ZModelLinker = class extends import_langium7.DefaultLinker {
 };
 
 // src/zmodel-scope.ts
-var import_langium8 = require("langium");
-var import_ts_pattern3 = require("ts-pattern");
-var ZModelScopeComputation = class extends import_langium8.DefaultScopeComputation {
+var import_langium11 = require("langium");
+var import_ts_pattern5 = require("ts-pattern");
+var ZModelScopeComputation = class extends import_langium11.DefaultScopeComputation {
   static {
     __name(this, "ZModelScopeComputation");
   }
@@ -7386,9 +8628,9 @@ var ZModelScopeComputation = class extends import_langium8.DefaultScopeComputati
   }
   async computeExports(document, cancelToken) {
     const result = await super.computeExports(document, cancelToken);
-    for (const node of import_langium8.AstUtils.streamAllContents(document.parseResult.value)) {
+    for (const node of import_langium11.AstUtils.streamAllContents(document.parseResult.value)) {
       if (cancelToken) {
-        await (0, import_langium8.interruptAndCheck)(cancelToken);
+        await (0, import_langium11.interruptAndCheck)(cancelToken);
       }
       if (isEnumField(node)) {
         const desc = this.services.workspace.AstNodeDescriptionProvider.createDescription(node, node.name, document);
@@ -7399,7 +8641,7 @@ var ZModelScopeComputation = class extends import_langium8.DefaultScopeComputati
   }
   processNode(node, document, scopes) {
     super.processNode(node, document, scopes);
-    if (isDataModel(node)) {
+    if (isDataModel(node) || isTypeDef(node)) {
       const bases = getRecursiveBases(node);
       for (const base of bases) {
         for (const field of base.fields) {
@@ -7409,7 +8651,7 @@ var ZModelScopeComputation = class extends import_langium8.DefaultScopeComputati
     }
   }
 };
-var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
+var ZModelScopeProvider = class extends import_langium11.DefaultScopeProvider {
   static {
     __name(this, "ZModelScopeProvider");
   }
@@ -7418,19 +8660,19 @@ var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
     super(services), this.services = services;
   }
   getGlobalScope(referenceType, context) {
-    const model = import_langium8.AstUtils.getContainerOfType(context.container, isModel);
+    const model = import_langium11.AstUtils.getContainerOfType(context.container, isModel);
     if (!model) {
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }
     const importedUris = model.imports.map(resolveImportUri).filter((url) => !!url);
     const importedElements = this.indexManager.allElements(referenceType).filter((des) => (
       // allow current document
-      import_langium8.UriUtils.equals(des.documentUri, model.$document?.uri) || // allow stdlib
+      import_langium11.UriUtils.equals(des.documentUri, model.$document?.uri) || // allow stdlib
       des.documentUri.path.endsWith(STD_LIB_MODULE_NAME) || // allow plugin models
       des.documentUri.path.endsWith(PLUGIN_MODULE_NAME) || // allow imported documents
-      importedUris.some((importedUri) => import_langium8.UriUtils.equals(des.documentUri, importedUri))
+      importedUris.some((importedUri) => import_langium11.UriUtils.equals(des.documentUri, importedUri))
     ));
-    return new import_langium8.StreamScope(importedElements);
+    return new import_langium11.StreamScope(importedElements);
   }
   getScope(context) {
     if (isMemberAccessExpr(context.container) && context.container.operand && context.property === "member") {
@@ -7450,66 +8692,66 @@ var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
     const node = context.container;
     const allowTypeDefScope = (
       // isAuthOrAuthMemberAccess(node.operand) ||
-      !!import_langium8.AstUtils.getContainerOfType(node, isTypeDef)
+      !!import_langium11.AstUtils.getContainerOfType(node, isTypeDef)
     );
-    return (0, import_ts_pattern3.match)(node.operand).when(isReferenceExpr, (operand) => {
+    return (0, import_ts_pattern5.match)(node.operand).when(isReferenceExpr, (operand) => {
       const ref = operand.target.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }).when(isMemberAccessExpr, (operand) => {
       const ref = operand.member.ref;
       if (isDataField(ref) && !ref.type.array) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }).when(isThisExpr, () => {
       return this.createScopeForContainingModel(node, globalScope);
     }).when(isInvocationExpr, (operand) => {
       if (isAuthInvocation(operand)) {
         return this.createScopeForAuth(node, globalScope);
       }
-      if (isFutureInvocation(operand)) {
+      if (isBeforeInvocation(operand)) {
         return this.createScopeForContainingModel(node, globalScope);
       }
-      return import_langium8.EMPTY_SCOPE;
-    }).otherwise(() => import_langium8.EMPTY_SCOPE);
+      return import_langium11.EMPTY_SCOPE;
+    }).otherwise(() => import_langium11.EMPTY_SCOPE);
   }
   getCollectionPredicateScope(context, collectionPredicate) {
     const referenceType = this.reflection.getReferenceType(context);
     const globalScope = this.getGlobalScope(referenceType, context);
     const collection = collectionPredicate.left;
     const allowTypeDefScope = false;
-    return (0, import_ts_pattern3.match)(collection).when(isReferenceExpr, (expr) => {
+    return (0, import_ts_pattern5.match)(collection).when(isReferenceExpr, (expr) => {
       const ref = expr.target.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }).when(isMemberAccessExpr, (expr) => {
       const ref = expr.member.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }).when(isInvocationExpr, (expr) => {
       const returnTypeDecl = expr.function.ref?.returnType.reference?.ref;
       if (isDataModel(returnTypeDecl)) {
         return this.createScopeForContainer(returnTypeDecl, globalScope, allowTypeDefScope);
       } else {
-        return import_langium8.EMPTY_SCOPE;
+        return import_langium11.EMPTY_SCOPE;
       }
     }).when(isAuthInvocation, (expr) => {
       return this.createScopeForAuth(expr, globalScope);
-    }).otherwise(() => import_langium8.EMPTY_SCOPE);
+    }).otherwise(() => import_langium11.EMPTY_SCOPE);
   }
   createScopeForContainingModel(node, globalScope) {
-    const model = import_langium8.AstUtils.getContainerOfType(node, isDataModel);
+    const model = import_langium11.AstUtils.getContainerOfType(node, isDataModel);
     if (model) {
       return this.createScopeForContainer(model, globalScope);
     } else {
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }
   }
   createScopeForContainer(node, globalScope, includeTypeDefScope = false) {
@@ -7518,16 +8760,16 @@ var ZModelScopeProvider = class extends import_langium8.DefaultScopeProvider {
     } else if (includeTypeDefScope && isTypeDef(node)) {
       return this.createScopeForNodes(node.fields, globalScope);
     } else {
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }
   }
   createScopeForAuth(node, globalScope) {
-    const decls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.services.shared.workspace.LangiumDocuments, import_langium8.AstUtils.getContainerOfType(node, isDataModel));
+    const decls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.services.shared.workspace.LangiumDocuments, import_langium11.AstUtils.getContainerOfType(node, isDataModel));
     const authDecl = getAuthDecl(decls);
     if (authDecl) {
       return this.createScopeForContainer(authDecl, globalScope, true);
     } else {
-      return import_langium8.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }
   }
 };
@@ -7543,13 +8785,97 @@ function getCollectionPredicateContext(node) {
 }
 __name(getCollectionPredicateContext, "getCollectionPredicateContext");
 
+// src/zmodel-semantic.ts
+var import_lsp4 = require("langium/lsp");
+var import_vscode_languageserver3 = require("vscode-languageserver");
+var ZModelSemanticTokenProvider = class extends import_lsp4.AbstractSemanticTokenProvider {
+  static {
+    __name(this, "ZModelSemanticTokenProvider");
+  }
+  highlightElement(node, acceptor) {
+    if (isDataModel(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: import_vscode_languageserver3.SemanticTokenTypes.type
+      });
+      acceptor({
+        node,
+        property: "mixins",
+        type: import_vscode_languageserver3.SemanticTokenTypes.type
+      });
+      acceptor({
+        node,
+        property: "baseModel",
+        type: import_vscode_languageserver3.SemanticTokenTypes.type
+      });
+    } else if (isDataSource(node) || isGeneratorDecl(node) || isPlugin(node) || isEnum(node) || isTypeDef(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: import_vscode_languageserver3.SemanticTokenTypes.type
+      });
+    } else if (isDataField(node) || isConfigField(node) || isAttributeArg(node) || isPluginField(node) || isEnumField(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: import_vscode_languageserver3.SemanticTokenTypes.variable
+      });
+    } else if (isDataFieldType(node)) {
+      if (node.type) {
+        acceptor({
+          node,
+          property: "type",
+          type: import_vscode_languageserver3.SemanticTokenTypes.type
+        });
+      } else {
+        acceptor({
+          node,
+          property: "reference",
+          type: import_vscode_languageserver3.SemanticTokenTypes.macro
+        });
+      }
+    } else if (isDataModelAttribute(node) || isDataFieldAttribute(node) || isInternalAttribute(node)) {
+      acceptor({
+        node,
+        property: "decl",
+        type: import_vscode_languageserver3.SemanticTokenTypes.function
+      });
+    } else if (isInvocationExpr(node)) {
+      acceptor({
+        node,
+        property: "function",
+        type: import_vscode_languageserver3.SemanticTokenTypes.function
+      });
+    } else if (isFunctionDecl(node) || isAttribute(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: import_vscode_languageserver3.SemanticTokenTypes.function
+      });
+    } else if (isReferenceExpr(node)) {
+      acceptor({
+        node,
+        property: "target",
+        type: import_vscode_languageserver3.SemanticTokenTypes.variable
+      });
+    } else if (isMemberAccessExpr(node)) {
+      acceptor({
+        node,
+        property: "member",
+        type: import_vscode_languageserver3.SemanticTokenTypes.property
+      });
+    }
+  }
+};
+
 // src/zmodel-workspace-manager.ts
-var import_langium9 = require("langium");
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var import_node_url = require("url");
-var import_meta = {};
-var ZModelWorkspaceManager = class extends import_langium9.DefaultWorkspaceManager {
+var import_langium12 = require("langium");
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+var import_meta2 = {};
+var ZModelWorkspaceManager = class extends import_langium12.DefaultWorkspaceManager {
   static {
     __name(this, "ZModelWorkspaceManager");
   }
@@ -7570,9 +8896,9 @@ var ZModelWorkspaceManager = class extends import_langium9.DefaultWorkspaceManag
             folderPath
           ]
         });
-        const languagePackageDir = import_node_path.default.dirname(languagePackagePath);
-        const candidateStdlibPath = import_node_path.default.join(languagePackageDir, "res", STD_LIB_MODULE_NAME);
-        if (import_node_fs2.default.existsSync(candidateStdlibPath)) {
+        const languagePackageDir = import_node_path2.default.dirname(languagePackagePath);
+        const candidateStdlibPath = import_node_path2.default.join(languagePackageDir, "res", STD_LIB_MODULE_NAME);
+        if (import_node_fs3.default.existsSync(candidateStdlibPath)) {
           installedStdlibPath = candidateStdlibPath;
           console.log(`Found installed zenstack package stdlib at: ${installedStdlibPath}`);
           break;
@@ -7584,73 +8910,12 @@ var ZModelWorkspaceManager = class extends import_langium9.DefaultWorkspaceManag
     if (installedStdlibPath) {
       stdLibPath = installedStdlibPath;
     } else {
-      const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
-      stdLibPath = import_node_path.default.join(_dirname, "../res", STD_LIB_MODULE_NAME);
+      const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path2.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
+      stdLibPath = import_node_path2.default.join(_dirname, "../res", STD_LIB_MODULE_NAME);
       console.log(`Using bundled stdlib in extension:`, stdLibPath);
     }
-    const stdlib = await this.documentFactory.fromUri(import_langium9.URI.file(stdLibPath));
+    const stdlib = await this.documentFactory.fromUri(import_langium12.URI.file(stdLibPath));
     collector(stdlib);
-    const documents = this.langiumDocuments.all;
-    const pluginModels = /* @__PURE__ */ new Set();
-    documents.forEach((doc) => {
-      const parsed = doc.parseResult.value;
-      parsed.declarations.forEach((decl) => {
-        if (isPlugin(decl)) {
-          const providerField = decl.fields.find((f) => f.name === "provider");
-          if (providerField) {
-            const provider = getLiteral(providerField.value);
-            if (provider) {
-              pluginModels.add(provider);
-            }
-          }
-        }
-      });
-    });
-    if (pluginModels.size > 0) {
-      console.log(`Used plugin modules: ${Array.from(pluginModels)}`);
-      const pendingPluginModules = new Set(pluginModels);
-      await Promise.all(folders.map((wf) => [
-        wf,
-        this.getRootFolder(wf)
-      ]).map(async (entry) => this.loadPluginModels(...entry, pendingPluginModules, collector)));
-    }
-  }
-  async loadPluginModels(workspaceFolder, folderPath, pendingPluginModels, collector) {
-    const content = (await this.fileSystemProvider.readDirectory(folderPath)).sort((a, b) => {
-      if (a.isDirectory && b.isDirectory) {
-        const aName = import_langium9.UriUtils.basename(a.uri);
-        if (aName === "node_modules") {
-          return -1;
-        } else {
-          return 1;
-        }
-      } else {
-        return 0;
-      }
-    });
-    for (const entry of content) {
-      if (entry.isDirectory) {
-        const name = import_langium9.UriUtils.basename(entry.uri);
-        if (name === "node_modules") {
-          for (const plugin of Array.from(pendingPluginModels)) {
-            const path4 = import_langium9.UriUtils.joinPath(entry.uri, plugin, PLUGIN_MODULE_NAME);
-            try {
-              await this.fileSystemProvider.readFile(path4);
-              const document = await this.langiumDocuments.getOrCreateDocument(path4);
-              collector(document);
-              console.log(`Adding plugin document from ${path4.path}`);
-              pendingPluginModels.delete(plugin);
-              if (pendingPluginModels.size === 0) {
-                return;
-              }
-            } catch {
-            }
-          }
-        } else {
-          await this.loadPluginModels(workspaceFolder, entry.uri, pendingPluginModels, collector);
-        }
-      }
-    }
   }
 };
 
@@ -7663,16 +8928,27 @@ var ZModelLanguageModule = {
   },
   validation: {
     ZModelValidator: /* @__PURE__ */ __name((services) => new ZModelValidator(services), "ZModelValidator")
+  },
+  lsp: {
+    Formatter: /* @__PURE__ */ __name((services) => new ZModelFormatter(services), "Formatter"),
+    DefinitionProvider: /* @__PURE__ */ __name((services) => new ZModelDefinitionProvider(services), "DefinitionProvider"),
+    CompletionProvider: /* @__PURE__ */ __name((services) => new ZModelCompletionProvider(services), "CompletionProvider"),
+    SemanticTokenProvider: /* @__PURE__ */ __name((services) => new ZModelSemanticTokenProvider(services), "SemanticTokenProvider")
+  },
+  documentation: {
+    CommentProvider: /* @__PURE__ */ __name((services) => new ZModelCommentProvider(services), "CommentProvider"),
+    DocumentationProvider: /* @__PURE__ */ __name((services) => new ZModelDocumentationProvider(services), "DocumentationProvider")
   }
 };
 var ZModelSharedModule = {
   workspace: {
+    DocumentBuilder: /* @__PURE__ */ __name((services) => new ZModelDocumentBuilder(services), "DocumentBuilder"),
     WorkspaceManager: /* @__PURE__ */ __name((services) => new ZModelWorkspaceManager(services), "WorkspaceManager")
   }
 };
-function createZModelLanguageServices(context) {
-  const shared = (0, import_langium10.inject)((0, import_lsp.createDefaultSharedModule)(context), ZModelGeneratedSharedModule, ZModelSharedModule);
-  const ZModelLanguage = (0, import_langium10.inject)((0, import_lsp.createDefaultModule)({
+function createZModelLanguageServices(context, logToConsole = false) {
+  const shared = (0, import_langium13.inject)((0, import_lsp5.createDefaultSharedModule)(context), ZModelGeneratedSharedModule, ZModelSharedModule);
+  const ZModelLanguage = (0, import_langium13.inject)((0, import_lsp5.createDefaultModule)({
     shared
   }), ZModelGeneratedModule, ZModelLanguageModule);
   shared.ServiceRegistry.register(ZModelLanguage);
@@ -7680,31 +8956,48 @@ function createZModelLanguageServices(context) {
   if (!context.connection) {
     shared.workspace.ConfigurationProvider.initialized({});
   }
+  shared.workspace.DocumentBuilder.onBuildPhase(import_langium13.DocumentState.Parsed, async (documents) => {
+    for (const doc of documents) {
+      if (doc.parseResult.lexerErrors.length > 0 || doc.parseResult.parserErrors.length > 0) {
+        continue;
+      }
+      if (doc.uri.scheme !== "file") {
+        continue;
+      }
+      const schemaPath = (0, import_node_url3.fileURLToPath)(doc.uri.toString());
+      const pluginSchemas = getPluginDocuments(doc.parseResult.value, schemaPath);
+      for (const plugin of pluginSchemas) {
+        const pluginDocUri = import_langium13.URI.file(import_node_path3.default.resolve(plugin));
+        let pluginDoc = shared.workspace.LangiumDocuments.getDocument(pluginDocUri);
+        if (!pluginDoc) {
+          pluginDoc = await shared.workspace.LangiumDocuments.getOrCreateDocument(pluginDocUri);
+          if (pluginDoc) {
+            shared.workspace.IndexManager.updateContent(pluginDoc);
+            if (logToConsole) {
+              console.log(`Loaded plugin model: ${plugin}`);
+            }
+          }
+        }
+      }
+    }
+  });
   return {
     shared,
     ZModelLanguage
   };
 }
 __name(createZModelLanguageServices, "createZModelLanguageServices");
-
-// src/index.ts
-var import_meta2 = {};
-function createZModelServices() {
-  return createZModelLanguageServices(import_node.NodeFileSystem);
+function createZModelServices(logToConsole = false) {
+  return createZModelLanguageServices(import_node.NodeFileSystem, logToConsole);
 }
 __name(createZModelServices, "createZModelServices");
-var DocumentLoadError = class extends Error {
-  static {
-    __name(this, "DocumentLoadError");
-  }
-  constructor(message) {
-    super(message);
-  }
-};
-async function loadDocument(fileName, pluginModelFiles = []) {
-  const { ZModelLanguage: services } = createZModelServices();
+
+// src/document.ts
+var import_meta3 = {};
+async function loadDocument(fileName, additionalModelFiles = []) {
+  const { ZModelLanguage: services } = createZModelServices(false);
   const extensions = services.LanguageMetaData.fileExtensions;
-  if (!extensions.includes(import_node_path2.default.extname(fileName))) {
+  if (!extensions.includes(import_node_path4.default.extname(fileName))) {
     return {
       success: false,
       errors: [
@@ -7713,7 +9006,7 @@ async function loadDocument(fileName, pluginModelFiles = []) {
       warnings: []
     };
   }
-  if (!import_node_fs3.default.existsSync(fileName)) {
+  if (!import_node_fs4.default.existsSync(fileName)) {
     return {
       success: false,
       errors: [
@@ -7722,23 +9015,27 @@ async function loadDocument(fileName, pluginModelFiles = []) {
       warnings: []
     };
   }
-  const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path2.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
-  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium11.URI.file(import_node_path2.default.resolve(import_node_path2.default.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
-  const pluginDocs = await Promise.all(pluginModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium11.URI.file(import_node_path2.default.resolve(file)))));
+  const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path4.default.dirname((0, import_node_url4.fileURLToPath)(import_meta3.url));
+  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium14.URI.file(import_node_path4.default.resolve(import_node_path4.default.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
-  const document = await langiumDocuments.getOrCreateDocument(import_langium11.URI.file(import_node_path2.default.resolve(fileName)));
+  const document = await langiumDocuments.getOrCreateDocument(import_langium14.URI.file(import_node_path4.default.resolve(fileName)));
   const importedURIs = await loadImports(document, langiumDocuments);
   const importedDocuments = [];
   for (const uri of importedURIs) {
     importedDocuments.push(await langiumDocuments.getOrCreateDocument(uri));
   }
+  const additionalDocs = await Promise.all(additionalModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium14.URI.file(import_node_path4.default.resolve(file)))));
   await services.shared.workspace.DocumentBuilder.build([
     stdLib,
-    ...pluginDocs,
+    ...additionalDocs,
     document,
     ...importedDocuments
   ], {
-    validation: true
+    validation: {
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true,
+      stopAfterLinkingErrors: true
+    }
   });
   const diagnostics = langiumDocuments.all.flatMap((doc) => (doc.diagnostics ?? []).map((diag) => ({
     doc,
@@ -7748,7 +9045,7 @@ async function loadDocument(fileName, pluginModelFiles = []) {
   const warnings = [];
   if (diagnostics.length > 0) {
     for (const { doc, diag } of diagnostics) {
-      const message = `${import_node_path2.default.relative(process.cwd(), doc.uri.fsPath)}:${diag.range.start.line + 1}:${diag.range.start.character + 1} - ${diag.message}`;
+      const message = `${import_node_path4.default.relative(process.cwd(), doc.uri.fsPath)}:${diag.range.start.line + 1}:${diag.range.start.character + 1} - ${diag.message}`;
       if (diag.severity === 1) {
         errors.push(message);
       } else {
@@ -7797,7 +9094,7 @@ async function loadImports(document, documents, uris = /* @__PURE__ */ new Set()
       }
     }
   }
-  return Array.from(uris).filter((x) => uriString != x).map((e) => import_langium11.URI.parse(e));
+  return Array.from(uris).filter((x) => uriString != x).map((e) => import_langium14.URI.parse(e));
 }
 __name(loadImports, "loadImports");
 function mergeImportsDeclarations(documents, model) {
@@ -7814,13 +9111,13 @@ function linkContentToContainer(node) {
     if (!name.startsWith("$")) {
       if (Array.isArray(value)) {
         value.forEach((item, index) => {
-          if ((0, import_langium11.isAstNode)(item)) {
+          if ((0, import_langium14.isAstNode)(item)) {
             item.$container = node;
             item.$containerProperty = name;
             item.$containerIndex = index;
           }
         });
-      } else if ((0, import_langium11.isAstNode)(value)) {
+      } else if ((0, import_langium14.isAstNode)(value)) {
         value.$container = node;
         value.$containerProperty = name;
       }
@@ -7848,7 +9145,7 @@ function validationAfterImportMerge(model) {
 __name(validationAfterImportMerge, "validationAfterImportMerge");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DocumentLoadError,
+  ZModelCodeGenerator,
   ZModelLanguageMetaData,
   ZModelLanguageModule,
   ZModelSharedModule,