@cratis/screenplay-language 4.52.0 → 4.54.0

package/dist/bundles/sub-languages/projection/index.js

@@ -0,0 +1,1647 @@
+import {
+  describeEventContext,
+  describeEventContextMember,
+  eventContextMemberAt,
+  eventContextMembers,
+  eventContextMembersAfter,
+  fenceMap,
+  validateEventContextPaths
+} from "../../chunk-GJX4NJYC.js";
+
+// sub-languages/projection/language.ts
+var languageId = "pdl";
+var KEYWORDS = [
+  "projection",
+  "sequence",
+  "all",
+  "every",
+  "on",
+  "from",
+  "key",
+  "parent",
+  "join",
+  "automap",
+  "no",
+  "children",
+  "nested",
+  "identified",
+  "by",
+  "add",
+  "subtract",
+  "remove",
+  "via",
+  "with",
+  "default",
+  "increment",
+  "decrement",
+  "count",
+  "set",
+  "unset",
+  "clear",
+  "events",
+  "id",
+  "exclude",
+  "variant",
+  "enters"
+];
+var BUILTINS = [
+  "$eventSourceId",
+  "$causedBy",
+  "$eventContext"
+];
+var OPERATORS = ["=", "+=", "-=", "=>", "."];
+var configuration = {
+  comments: {
+    lineComment: "#"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" },
+    { open: "`", close: "`" }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" },
+    { open: "`", close: "`" }
+  ],
+  indentationRules: {
+    increaseIndentPattern: /^.*(:|\bon\b|\ball\b|\bevery\b|\bchildren\b|\bnested\b|\bparent\b|\bvariant\b)\s*$/,
+    decreaseIndentPattern: /^.*\}.*$/
+  },
+  folding: {
+    offSide: true,
+    markers: {
+      start: /^\s*(projection|all|every|on|children|nested|parent|variant)/,
+      end: /^\s*$/
+    }
+  },
+  wordPattern: /@?[a-zA-Z_$][\w$-]*/
+};
+var monarchLanguage = {
+  defaultToken: "",
+  tokenPostfix: ".pdl",
+  keywords: KEYWORDS,
+  builtins: BUILTINS,
+  operators: OPERATORS,
+  // Symbols
+  symbols: /[=><!~?:&|+\-*/^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  tokenizer: {
+    root: [
+      // Whitespace
+      { include: "@whitespace" },
+      // Template strings with ${...} interpolation
+      [/`/, { token: "string.template", next: "@templateString" }],
+      // Escaped identifiers (@ prefix allows using keywords as identifiers)
+      [/@[a-zA-Z_$][\w$]*/, "identifier.escape"],
+      // Check for uppercase keywords (error case - keywords must be lowercase)
+      [
+        /[A-Z][a-zA-Z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": "invalid",
+            "@default": "identifier"
+          }
+        }
+      ],
+      // Identifiers and keywords (lowercase only for keywords)
+      [
+        /[a-z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@builtins": "variable.predefined",
+            "@default": "identifier"
+          }
+        }
+      ],
+      // Delimiters and operators
+      [/[{}()[\]]/, "@brackets"],
+      [/=>/, "operator.arrow"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "operator",
+            "@default": ""
+          }
+        }
+      ],
+      // Numbers
+      [/\d*\.\d+([eE][-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F]+/, "number.hex"],
+      [/\d+/, "number"],
+      // Delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // Strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      [/"/, { token: "string.quote", next: "@string" }]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/#.*$/, "comment"]
+    ],
+    // Template string state
+    templateString: [
+      [/\$\{/, { token: "delimiter.bracket", next: "@templateExpression" }],
+      [/[^\\`$]+/, "string.template"],
+      [/@escapes/, "string.template.escape"],
+      [/\\./, "string.template.escape.invalid"],
+      [/`/, { token: "string.template", next: "@pop" }]
+    ],
+    // Template expression inside ${}
+    templateExpression: [
+      [/\}/, { token: "delimiter.bracket", next: "@pop" }],
+      { include: "@root" }
+    ],
+    // Regular string state
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ]
+  }
+};
+
+// sub-languages/projection/CompletionProvider.ts
+var EVENT_CONTEXT_PATH = /\$eventContext\.((?:\w+\.)*)(\w*)$/;
+var CompletionProvider = class {
+  readModels = [];
+  eventSchemas = {};
+  eventSequences = [];
+  setReadModels(readModels) {
+    this.readModels = readModels || [];
+  }
+  setEventSequences(sequences) {
+    this.eventSequences = sequences || [];
+  }
+  // Keep for backwards compatibility
+  setReadModelSchemas(schemas) {
+    this.readModels = schemas.map((schema) => ({
+      identifier: this.getSchemaName(schema) || "",
+      displayName: this.getSchemaName(schema) || "",
+      schema
+    }));
+  }
+  setEventSchemas(schemas) {
+    if (!schemas) {
+      this.eventSchemas = {};
+      return;
+    }
+    if (Array.isArray(schemas)) {
+      const map = {};
+      schemas.forEach((s, i) => {
+        if (!s) return;
+        const name = this.getSchemaName(s) || `Event${i + 1}`;
+        map[name] = s;
+      });
+      this.eventSchemas = map;
+      return;
+    }
+    this.eventSchemas = schemas;
+  }
+  provideCompletionItems(model, position) {
+    const context = this.buildContext(model, position);
+    const suggestions = [];
+    const activeSchema = this.getActiveReadModelSchema(model);
+    if (context.lineNumber === 1) {
+      this.addProjectionLineCompletions(suggestions, context);
+    } else if (this.isAfterKeyword(context, "sequence")) {
+      this.addEventSequenceCompletions(suggestions, context);
+    } else if (this.isAfterKeyword(context, "from") || this.isAfterKeyword(context, "every")) {
+      this.addEventTypeCompletions(suggestions, context);
+    } else if (/\benters\s+on\s+\w*$/.test(context.textBeforeCursor)) {
+      this.addEventTypeCompletions(suggestions, context);
+    } else if (/\benters\s+\w*$/.test(context.textBeforeCursor)) {
+      suggestions.push({
+        label: "on",
+        kind: 14,
+        // Keyword
+        insertText: "on ",
+        documentation: "Declares the event that activates this variant.",
+        detail: "enters on <EventType>",
+        range: this.getRangeForWord(context)
+      });
+    } else if (this.isAfterKeyword(context, "variant")) {
+      this.addVariantNameCompletions(suggestions, context);
+    } else if (this.isAfterKeyword(context, "key")) {
+      this.addKeyCompletions(suggestions, context, activeSchema);
+    } else if (this.isAfterKeyword(context, "parent")) {
+      this.addParentCompletions(suggestions, context);
+    } else if (this.isAfterKeyword(context, "children")) {
+      this.addChildrenCompletions(suggestions, context, activeSchema);
+    } else if (this.isAfterKeyword(context, "join")) {
+      this.addJoinCompletions(suggestions, context, activeSchema);
+    } else if (this.isAfterKeyword(context, "with")) {
+      this.addEventTypeCompletions(suggestions, context);
+    } else if (this.isAfterNumericOperationKeyword(context)) {
+      this.addNumericPropertyCompletions(suggestions, context, activeSchema);
+    } else if (this.isAfterAddOrSubtractBy(context)) {
+      this.addAssignmentValueCompletions(suggestions, context, model, position);
+    } else if (this.isInAssignment(context)) {
+      this.addAssignmentValueCompletions(suggestions, context, model, position);
+    } else if (this.isPropertyDotAccess(context)) {
+      this.addPropertyMemberCompletions(suggestions, context);
+    } else if (this.isStartOfLine(context) || this.isAfterIndent(context)) {
+      this.addStatementCompletions(suggestions, context, activeSchema);
+    }
+    return { suggestions };
+  }
+  buildContext(model, position) {
+    const lineContent = model.getLineContent(position.lineNumber);
+    const textBeforeCursor = lineContent.substring(0, position.column - 1);
+    const textAfterCursor = lineContent.substring(position.column - 1);
+    const word = model.getWordAtPosition(position);
+    const currentWord = word?.word || "";
+    const indentLevel = this.getIndentLevel(textBeforeCursor);
+    return {
+      lineContent,
+      textBeforeCursor,
+      textAfterCursor,
+      currentWord,
+      indentLevel,
+      lineNumber: position.lineNumber
+    };
+  }
+  getIndentLevel(text) {
+    const match = text.match(/^(\s*)/);
+    return match ? Math.floor(match[1].length / 2) : 0;
+  }
+  isStartOfLine(context) {
+    return context.textBeforeCursor.trim() === "";
+  }
+  isAfterIndent(context) {
+    return /^\s+$/.test(context.textBeforeCursor);
+  }
+  isAfterKeyword(context, keyword) {
+    const pattern = new RegExp(`\\b${keyword}\\s+\\w*$`);
+    return pattern.test(context.textBeforeCursor);
+  }
+  isAfterNumericOperationKeyword(context) {
+    const countIncrDecrPattern = /\b(count|increment|decrement)\s+\w*$/;
+    const addSubtractPattern = /\b(add|subtract)\s+\w*$/;
+    if (countIncrDecrPattern.test(context.textBeforeCursor)) {
+      return true;
+    }
+    if (addSubtractPattern.test(context.textBeforeCursor)) {
+      return !this.isAfterAddOrSubtractBy(context);
+    }
+    return false;
+  }
+  isAfterAddOrSubtractBy(context) {
+    const pattern = /\b(add|subtract)\s+\w+\s+by\s+\w*$/;
+    return pattern.test(context.textBeforeCursor);
+  }
+  isInAssignment(context) {
+    return /\w+\s*=\s*\w*$/.test(context.textBeforeCursor);
+  }
+  isPropertyDotAccess(context) {
+    return /(\w+|\$\w+)\.(\w*)$/.test(context.textBeforeCursor) || EVENT_CONTEXT_PATH.test(context.textBeforeCursor);
+  }
+  addProjectionLineCompletions(suggestions, context) {
+    const trimmed = context.textBeforeCursor.trim();
+    if (trimmed === "" || "projection".startsWith(trimmed)) {
+      suggestions.push({
+        label: "projection",
+        kind: 14,
+        // Keyword
+        insertText: "projection ",
+        documentation: "Define a projection that transforms events into a read model",
+        detail: "projection <ProjectionName>",
+        range: this.getRangeForWord(context)
+      });
+    }
+    const arrowMatch = trimmed.match(/^projection\s+[\w.]+\s*=>\s*([\w.]*)$/);
+    if (arrowMatch) {
+      const partialReadModel = arrowMatch[1] || "";
+      this.readModels.forEach((readModel) => {
+        if (!partialReadModel || readModel.displayName.toLowerCase().startsWith(partialReadModel.toLowerCase())) {
+          const label = `${readModel.displayName} (${readModel.identifier})`;
+          suggestions.push({
+            label,
+            kind: 6,
+            // Class
+            insertText: readModel.displayName,
+            filterText: `${readModel.displayName} ${readModel.identifier}`,
+            documentation: `Read model: ${readModel.displayName} (${readModel.identifier})`,
+            detail: readModel.identifier,
+            range: this.getRangeForWord(context)
+          });
+        }
+      });
+      return;
+    }
+    if (trimmed.startsWith("projection ") && !trimmed.includes("=>")) {
+      const afterProjection = trimmed.substring("projection ".length);
+      this.readModels.forEach((readModel) => {
+        if (!afterProjection || readModel.displayName.toLowerCase().startsWith(afterProjection.toLowerCase())) {
+          const label = `${readModel.displayName} (${readModel.identifier})`;
+          suggestions.push({
+            label,
+            kind: 6,
+            // Class
+            insertText: `${readModel.displayName} => ${readModel.displayName}`,
+            filterText: `${readModel.displayName} ${readModel.identifier}`,
+            documentation: `Read model: ${readModel.displayName} (${readModel.identifier})`,
+            detail: readModel.identifier,
+            range: this.getRangeForWord(context)
+          });
+        }
+      });
+    }
+  }
+  addEventTypeCompletions(suggestions, context) {
+    Object.keys(this.eventSchemas).forEach((eventName) => {
+      if (!context.currentWord || eventName.startsWith(context.currentWord)) {
+        const schema = this.eventSchemas[eventName];
+        suggestions.push({
+          label: eventName,
+          kind: 6,
+          // Class
+          insertText: eventName,
+          documentation: this.getSchemaDescription(schema) || `Event type: ${eventName}`,
+          detail: "Event Type",
+          range: this.getRangeForWord(context)
+        });
+      }
+    });
+  }
+  addEventSequenceCompletions(suggestions, context) {
+    this.eventSequences.forEach((sequenceId) => {
+      if (!context.currentWord || sequenceId.startsWith(context.currentWord)) {
+        suggestions.push({
+          label: sequenceId,
+          kind: 13,
+          // Value
+          insertText: sequenceId,
+          documentation: `Event sequence: ${sequenceId}`,
+          detail: "Event Sequence",
+          range: this.getRangeForWord(context)
+        });
+      }
+    });
+  }
+  addKeyCompletions(suggestions, context, activeSchema) {
+    if (activeSchema?.definitions) {
+      Object.keys(activeSchema.definitions).forEach((typeName) => {
+        const typeDef = activeSchema.definitions[typeName];
+        if (typeDef.type === "object") {
+          suggestions.push({
+            label: typeName,
+            kind: 6,
+            // Class
+            insertText: typeName,
+            documentation: `Composite key type: ${typeName}`,
+            detail: "Composite Key Type",
+            range: this.getRangeForWord(context)
+          });
+        }
+      });
+    }
+    this.addExpressionCompletions(suggestions, context);
+  }
+  addParentCompletions(suggestions, context) {
+    this.addExpressionCompletions(suggestions, context);
+  }
+  addNumericPropertyCompletions(suggestions, context, activeSchema) {
+    if (activeSchema?.properties) {
+      Object.entries(activeSchema.properties).forEach(([propName, propSchema]) => {
+        const isNumeric = propSchema.type === "integer" || propSchema.type === "number";
+        if (isNumeric) {
+          if (!context.currentWord || propName.startsWith(context.currentWord)) {
+            suggestions.push({
+              label: propName,
+              kind: 9,
+              // Property
+              insertText: propName,
+              documentation: `Numeric property: ${propName}`,
+              detail: this.getPropertyTypeDescription(propSchema),
+              range: this.getRangeForWord(context)
+            });
+          }
+        }
+      });
+    }
+    const addSubtractMatch = context.textBeforeCursor.match(/\b(add|subtract)\s+(\w*)$/);
+    if (addSubtractMatch) {
+      const partialProp = addSubtractMatch[2] || "";
+      if (activeSchema?.properties) {
+        Object.entries(activeSchema.properties).forEach(([propName, propSchema]) => {
+          const isNumeric = propSchema.type === "integer" || propSchema.type === "number";
+          if (isNumeric && (!partialProp || propName.startsWith(partialProp))) {
+            suggestions.push({
+              label: propName,
+              kind: 9,
+              // Property
+              insertText: `${propName} by `,
+              documentation: `Numeric property: ${propName}`,
+              detail: this.getPropertyTypeDescription(propSchema),
+              range: this.getRangeForWord(context)
+            });
+          }
+        });
+      }
+    }
+  }
+  addChildrenCompletions(suggestions, context, activeSchema) {
+    if (activeSchema?.properties) {
+      Object.entries(activeSchema.properties).forEach(([propName, propSchema]) => {
+        if (propSchema.type === "array" || propSchema.items) {
+          suggestions.push({
+            label: propName,
+            kind: 9,
+            // Property
+            insertText: `${propName} id `,
+            documentation: `Collection property: ${propName}`,
+            detail: this.getPropertyTypeDescription(propSchema),
+            range: this.getRangeForWord(context)
+          });
+        }
+      });
+    }
+  }
+  addJoinCompletions(suggestions, context, activeSchema) {
+    const trimmed = context.textBeforeCursor.trim();
+    if (trimmed === "join" || !trimmed.includes(" ")) {
+      if (activeSchema?.properties) {
+        Object.entries(activeSchema.properties).forEach(([propName, propSchema]) => {
+          if (propSchema.type === "array" || propSchema.items) {
+            suggestions.push({
+              label: propName,
+              kind: 9,
+              insertText: `${propName} on `,
+              documentation: `Join on collection: ${propName}`,
+              range: this.getRangeForWord(context)
+            });
+          }
+        });
+      }
+    } else if (trimmed.match(/join\s+\w+\s+on\s+/)) {
+      if (activeSchema?.properties) {
+        Object.keys(activeSchema.properties).forEach((propName) => {
+          suggestions.push({
+            label: propName,
+            kind: 9,
+            insertText: propName,
+            documentation: `Property: ${propName}`,
+            range: this.getRangeForWord(context)
+          });
+        });
+      }
+    }
+  }
+  addVariantNameCompletions(suggestions, context) {
+    this.readModels.forEach((readModel) => {
+      if (!context.currentWord || readModel.displayName.toLowerCase().startsWith(context.currentWord.toLowerCase())) {
+        suggestions.push({
+          label: readModel.displayName,
+          kind: 6,
+          // Class
+          insertText: readModel.displayName,
+          documentation: `Read model: ${readModel.displayName} (${readModel.identifier})`,
+          detail: readModel.identifier,
+          range: this.getRangeForWord(context)
+        });
+      }
+    });
+  }
+  addStatementCompletions(suggestions, context, activeSchema) {
+    const keywords = [
+      { label: "sequence", insertText: "sequence ", documentation: "Specify which event sequence to use for this projection", detail: "sequence <event-sequence-id>" },
+      { label: "variant", insertText: "variant ", documentation: "Declare one of several mutually exclusive named read models sharing this projection's identity", detail: "variant <Name>" },
+      { label: "enters on", insertText: "enters on ", documentation: "Declare the event that activates a variant", detail: "enters on <EventType>" },
+      { label: "from", insertText: "from ", documentation: "Handle specific event types", detail: "from <EventType>" },
+      { label: "all", insertText: "all", documentation: "Subscribe to all event types in the system \u2014 mappings run for every event system-wide, regardless of explicit from blocks", detail: "all" },
+      { label: "every", insertText: "every", documentation: "Handle all events for automatic mapping (only events explicitly subscribed to via from blocks)", detail: "every" },
+      { label: "key", insertText: "key ", documentation: "Define the projection key", detail: "key <expression>" },
+      { label: "parent", insertText: "parent ", documentation: "Define parent relationship", detail: "parent <expression>" },
+      { label: "join", insertText: "join ", documentation: "Join with child collection", detail: "join <collection> on <property>" },
+      { label: "children", insertText: "children ", documentation: "Define child collection operations", detail: "children <collection> identified by <expression>" },
+      { label: "remove with", insertText: "remove with ", documentation: "Remove items based on event", detail: "remove with <EventType>" },
+      { label: "remove via", insertText: "remove via join on ", documentation: "Remove items via join", detail: "remove via join on <EventType>" },
+      { label: "no automap", insertText: "no automap", documentation: "Disable automatic property mapping", detail: "no automap" },
+      { label: "clear", insertText: "clear ", documentation: "Remove the value a property holds", detail: "clear <property>" },
+      { label: "increment", insertText: "increment ", documentation: "Increment a numeric property", detail: "increment <property>" },
+      { label: "decrement", insertText: "decrement ", documentation: "Decrement a numeric property", detail: "decrement <property>" },
+      { label: "count", insertText: "count ", documentation: "Count occurrences", detail: "count <property>" },
+      { label: "add", insertText: "add ", documentation: "Add value to property", detail: "add <property> by <expression>" },
+      { label: "subtract", insertText: "subtract ", documentation: "Subtract value from property", detail: "subtract <property> by <expression>" },
+      { label: "exclude children", insertText: "exclude children", documentation: "Exclude child collections from automap", detail: "exclude children" }
+    ];
+    keywords.forEach((kw) => {
+      if (!context.currentWord || kw.label.startsWith(context.currentWord)) {
+        suggestions.push({
+          label: kw.label,
+          kind: 14,
+          // Keyword
+          insertText: kw.insertText,
+          documentation: kw.documentation,
+          detail: kw.detail,
+          range: this.getRangeForWord(context)
+        });
+      }
+    });
+    if (activeSchema?.properties) {
+      Object.entries(activeSchema.properties).forEach(([propName, propSchema]) => {
+        if (!context.currentWord || propName.startsWith(context.currentWord)) {
+          suggestions.push({
+            label: propName,
+            kind: 9,
+            // Property
+            insertText: `${propName} = `,
+            documentation: `Assign value to property: ${propName}`,
+            detail: this.getPropertyTypeDescription(propSchema),
+            range: this.getRangeForWord(context)
+          });
+        }
+      });
+    }
+  }
+  addAssignmentValueCompletions(suggestions, context, model, position) {
+    const eventType = this.getCurrentEventType(model, position.lineNumber);
+    if (eventType && this.eventSchemas[eventType]) {
+      const eventSchema = this.eventSchemas[eventType];
+      if (eventSchema.properties) {
+        Object.entries(eventSchema.properties).forEach(([propName, propSchema]) => {
+          suggestions.push({
+            label: propName,
+            kind: 9,
+            insertText: propName,
+            documentation: `Event property: ${propName}`,
+            detail: this.getPropertyTypeDescription(propSchema),
+            range: this.getRangeForWord(context)
+          });
+        });
+      }
+    }
+    this.addExpressionCompletions(suggestions, context);
+  }
+  addExpressionCompletions(suggestions, context) {
+    const expressions = [
+      {
+        label: "$eventSourceId",
+        insertText: "$eventSourceId",
+        documentation: "The identifier of the event source (aggregate/entity)",
+        detail: "Event Source Expression"
+      },
+      {
+        label: "$causedBy",
+        insertText: "$causedBy",
+        documentation: "The identity that caused the event. Chronicle cannot yet evaluate this short form (Cratis/Chronicle#4119) - prefer $eventContext.causedBy.<property>.",
+        detail: "Identity Expression"
+      },
+      {
+        label: "$eventContext",
+        insertText: "$eventContext.",
+        documentation: `Metadata about the event: ${eventContextMembers.map((member) => member.name).join(", ")}`,
+        detail: "Event Context Expression"
+      }
+    ];
+    expressions.forEach((expr) => {
+      if (!context.currentWord || expr.label.startsWith(context.currentWord) || expr.label.startsWith("$" + context.currentWord)) {
+        suggestions.push({
+          label: expr.label,
+          kind: 14,
+          // Keyword/builtin
+          insertText: expr.insertText,
+          documentation: expr.documentation,
+          detail: expr.detail,
+          range: this.getRangeForWord(context)
+        });
+      }
+    });
+  }
+  addPropertyMemberCompletions(suggestions, context) {
+    const eventContextMatch = context.textBeforeCursor.match(EVENT_CONTEXT_PATH);
+    if (eventContextMatch) {
+      const segments = eventContextMatch[1].split(".").filter((segment) => segment.length > 0);
+      this.addEventContextMemberCompletions(suggestions, context, segments, eventContextMatch[2]);
+      return;
+    }
+    const match = context.textBeforeCursor.match(/(\w+|\$\w+)\.(\w*)$/);
+    if (!match) return;
+    const [, objectName, partialProp] = match;
+    const causedByMatch = context.textBeforeCursor.match(/\$causedBy\.((?:\w+\.)*)(\w*)$/);
+    if (causedByMatch) {
+      const segments = causedByMatch[1].split(".").filter((segment) => segment.length > 0);
+      this.addEventContextMemberCompletions(suggestions, context, ["causedBy", ...segments], causedByMatch[2]);
+      return;
+    }
+    const eventSchema = this.eventSchemas[objectName];
+    if (eventSchema?.properties) {
+      Object.entries(eventSchema.properties).forEach(([propName, propSchema]) => {
+        if (!partialProp || propName.startsWith(partialProp)) {
+          suggestions.push({
+            label: propName,
+            kind: 9,
+            insertText: propName,
+            documentation: `Event property: ${propName}`,
+            detail: this.getPropertyTypeDescription(propSchema),
+            range: this.getRangeForWord(context)
+          });
+        }
+      });
+    }
+  }
+  addEventContextMemberCompletions(suggestions, context, segments, partial) {
+    const members = eventContextMembersAfter(segments) ?? [];
+    members.filter((member) => !partial || member.name.startsWith(partial)).forEach((member) => {
+      suggestions.push({
+        label: member.name,
+        kind: member.kind === "function" ? 1 : 9,
+        insertText: member.name,
+        documentation: member.description,
+        detail: member.type,
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  getCurrentEventType(model, lineNumber) {
+    for (let i = lineNumber; i >= 1; i--) {
+      const line = model.getLineContent(i).trim();
+      const fromMatch = line.match(/^from\s+([\w-]+)/);
+      if (fromMatch) {
+        return fromMatch[1];
+      }
+      const everyMatch = line.match(/^every$/);
+      if (everyMatch) {
+        return null;
+      }
+    }
+    return null;
+  }
+  getActiveReadModelSchema(model) {
+    const firstLine = model.getLineContent(1).trim();
+    const match = firstLine.match(/^projection\s+[\w.]+\s*=>\s*([\w.]+)/);
+    if (!match) return void 0;
+    const readModelName = match[1];
+    const readModel = this.resolveReadModelInfo(readModelName);
+    return readModel?.schema;
+  }
+  resolveReadModelInfo(readModelToken) {
+    return this.readModels.find((rm) => rm.identifier === readModelToken || rm.displayName === readModelToken) || null;
+  }
+  getSchemaName(schema) {
+    if (schema.name) return schema.name;
+    if (schema.title) return schema.title;
+    if (typeof schema.$id === "string") {
+      const parts = schema.$id.split("/");
+      return parts[parts.length - 1] || schema.$id;
+    }
+    return void 0;
+  }
+  getSchemaDescription(schema) {
+    return schema.description || void 0;
+  }
+  getPropertyTypeDescription(propSchema) {
+    if (propSchema.type === "array" && propSchema.items) {
+      const itemType = propSchema.items.type || propSchema.items.$id?.split("/").pop() || "unknown";
+      return `${itemType}[]`;
+    }
+    return propSchema.type || propSchema.$ref?.split("/").pop() || "unknown";
+  }
+  getRangeForWord(context) {
+    const startColumn = context.textBeforeCursor.length - context.currentWord.length + 1;
+    const endColumn = startColumn + context.currentWord.length;
+    return {
+      startLineNumber: context.lineNumber,
+      startColumn: Math.max(1, startColumn),
+      endLineNumber: context.lineNumber,
+      endColumn: Math.max(1, endColumn)
+    };
+  }
+};
+
+// sub-languages/projection/Validator.ts
+var Validator = class {
+  readModels = [];
+  eventSchemas = {};
+  draftReadModel = null;
+  setReadModels(readModels) {
+    this.readModels = readModels || [];
+  }
+  setDraftReadModel(draft) {
+    this.draftReadModel = draft;
+  }
+  // Keep for backwards compatibility
+  setReadModelSchemas(schemas) {
+    this.readModels = schemas.map((schema) => ({
+      identifier: this.getSchemaName(schema) || "",
+      displayName: this.getSchemaName(schema) || "",
+      schema
+    }));
+  }
+  setEventSchemas(schemas) {
+    if (!schemas) {
+      this.eventSchemas = {};
+      return;
+    }
+    if (Array.isArray(schemas)) {
+      const map = {};
+      schemas.forEach((s, i) => {
+        if (!s) return;
+        const name = this.getSchemaName(s) || `Event${i + 1}`;
+        map[name] = s;
+      });
+      this.eventSchemas = map;
+      return;
+    }
+    this.eventSchemas = schemas;
+  }
+  validate(model) {
+    const markers = [];
+    const content = model.getValue();
+    if (!content.trim()) {
+      return markers;
+    }
+    const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+    let firstNonEmptyLineIndex = 0;
+    let firstLine = "";
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        firstNonEmptyLineIndex = i;
+        firstLine = trimmed;
+        break;
+      }
+    }
+    if (!firstLine) {
+      return markers;
+    }
+    const projectionWithReadModelMatch = firstLine.match(/^projection\s+([\w.]+)\s*=>\s*([\w.]+)\s*$/);
+    const projectionAdHocMatch = !projectionWithReadModelMatch && firstLine.match(/^projection\s+([\w.]+)\s*$/);
+    if (!projectionWithReadModelMatch && !projectionAdHocMatch) {
+      const lineNumber = firstNonEmptyLineIndex + 1;
+      markers.push(this.createError(lineNumber, 1, firstLine.length + 1, 'Projection definition must start with "projection <ProjectionName>" or "projection <ProjectionName> => <ReadModelIdentifier>"'));
+      return markers;
+    }
+    let activeSchema;
+    let readModelName = null;
+    if (projectionWithReadModelMatch) {
+      readModelName = projectionWithReadModelMatch[2];
+      const readModelExists = this.resolveReadModelIdentifier(readModelName) !== null;
+      const isDraftReadModel = this.isDraftReadModel(readModelName);
+      const readModelStartColumn = this.getReadModelStartColumn(firstLine, readModelName);
+      if (!readModelExists && !isDraftReadModel) {
+        const lineNumber = firstNonEmptyLineIndex + 1;
+        const col = readModelStartColumn;
+        markers.push(this.createError(lineNumber, col, col + readModelName.length, `Read model '${readModelName}' not found`));
+      } else if (isDraftReadModel) {
+        const lineNumber = firstNonEmptyLineIndex + 1;
+        const col = readModelStartColumn;
+        markers.push(this.createInfo(lineNumber, col, col + readModelName.length, `Read model '${readModelName}' is a draft (not yet saved)`));
+      }
+      const isDraft = this.isDraftReadModel(readModelName);
+      const activeReadModel = isDraft ? null : this.resolveReadModelInfo(readModelName);
+      activeSchema = isDraft ? this.draftReadModel.schema : activeReadModel?.schema;
+    }
+    const contextStack = [activeSchema];
+    const indentStack = [0];
+    let lastIndent = 0;
+    const eventContextStack = [/* @__PURE__ */ new Map()];
+    for (let i = 1; i < lines.length; i++) {
+      const lineNumber = i + 1;
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const currentIndent = line.search(/\S/);
+      while (currentIndent < lastIndent && indentStack.length > 1) {
+        const poppedIndent = indentStack.pop();
+        if (poppedIndent !== void 0 && currentIndent < poppedIndent) {
+          contextStack.pop();
+          eventContextStack.pop();
+        }
+      }
+      lastIndent = currentIndent;
+      const currentEventContext = eventContextStack[eventContextStack.length - 1];
+      const fromMatch = trimmed.match(/^from\s+([\w-]+)/);
+      if (fromMatch) {
+        const eventType = fromMatch[1];
+        const col = line.indexOf(eventType) + 1;
+        if (Object.keys(this.eventSchemas).length > 0 && !this.eventSchemas[eventType]) {
+          markers.push(this.createError(lineNumber, col, col + eventType.length, `Event type '${eventType}' not found`));
+        }
+        if (currentEventContext.has(eventType)) {
+          markers.push(this.createError(lineNumber, col, col + eventType.length, `Duplicate event type '${eventType}' - event types can only be used once at each level`));
+        } else {
+          currentEventContext.set(eventType, { lineNumber, col });
+        }
+      }
+      const variantMatch = trimmed.match(/^variant\s+([\w.]+)\s*$/);
+      if (variantMatch) {
+        const [, variantName] = variantMatch;
+        const col = line.indexOf(variantName) + 1;
+        const isDraft = this.isDraftReadModel(variantName);
+        const readModelExists = this.resolveReadModelIdentifier(variantName) !== null;
+        if (!readModelExists && !isDraft) {
+          markers.push(this.createError(lineNumber, col, col + variantName.length, `Read model '${variantName}' not found`));
+        } else if (isDraft) {
+          markers.push(this.createInfo(lineNumber, col, col + variantName.length, `Read model '${variantName}' is a draft (not yet saved)`));
+        }
+        const variantSchema = isDraft ? this.draftReadModel.schema : this.resolveReadModelInfo(variantName)?.schema;
+        contextStack.push(variantSchema);
+        indentStack.push(currentIndent);
+        eventContextStack.push(/* @__PURE__ */ new Map());
+      }
+      const entersOnMatch = trimmed.match(/^enters\s+on\s+([\w-]+)/);
+      if (entersOnMatch) {
+        const eventType = entersOnMatch[1];
+        const col = line.indexOf(eventType) + 1;
+        if (Object.keys(this.eventSchemas).length > 0 && !this.eventSchemas[eventType]) {
+          markers.push(this.createError(lineNumber, col, col + eventType.length, `Event type '${eventType}' not found`));
+        }
+        if (currentEventContext.has(eventType)) {
+          markers.push(this.createError(lineNumber, col, col + eventType.length, `Duplicate event type '${eventType}' - event types can only be used once at each level`));
+        } else {
+          currentEventContext.set(eventType, { lineNumber, col });
+        }
+      }
+      const eventsMatch = trimmed.match(/^events\s+([\w-]+)/);
+      if (eventsMatch) {
+        const eventType = eventsMatch[1];
+        const col = line.indexOf(eventType) + 1;
+        if (Object.keys(this.eventSchemas).length > 0 && !this.eventSchemas[eventType]) {
+          markers.push(this.createError(lineNumber, col, col + eventType.length, `Event type '${eventType}' not found`));
+        }
+        if (currentEventContext.has(eventType)) {
+          markers.push(this.createError(lineNumber, col, col + eventType.length, `Duplicate event type '${eventType}' - event types can only be used once at each level`));
+        } else {
+          currentEventContext.set(eventType, { lineNumber, col });
+        }
+      }
+      const removeWithMatch = trimmed.match(/^remove\s+(?:with|via\s+join\s+on)\s+([\w-]+)/);
+      if (removeWithMatch) {
+        const eventType = removeWithMatch[1];
+        const col = line.indexOf(eventType) + 1;
+        if (Object.keys(this.eventSchemas).length > 0 && !this.eventSchemas[eventType]) {
+          markers.push(this.createError(lineNumber, col, col + eventType.length, `Event type '${eventType}' not found`));
+        }
+        if (currentEventContext.has(eventType)) {
+          markers.push(this.createError(lineNumber, col, col + eventType.length, `Duplicate event type '${eventType}' - event types can only be used once at each level`));
+        } else {
+          currentEventContext.set(eventType, { lineNumber, col });
+        }
+      }
+      const assignmentMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+      if (assignmentMatch) {
+        const currentSchema = contextStack[contextStack.length - 1];
+        if (currentSchema?.properties) {
+          const [, propertyName] = assignmentMatch;
+          if (!currentSchema.properties[propertyName]) {
+            const col = line.indexOf(propertyName) + 1;
+            const schemaName = this.getSchemaName(currentSchema) || "current schema";
+            markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Property '${propertyName}' not found in ${schemaName}`));
+          }
+        }
+      }
+      const numericOpMatch = trimmed.match(/^(?:increment|decrement|count)\s+(\w+)$/);
+      if (numericOpMatch) {
+        const currentSchema = contextStack[contextStack.length - 1];
+        if (currentSchema?.properties) {
+          const [, propertyName] = numericOpMatch;
+          if (!currentSchema.properties[propertyName]) {
+            const col = line.indexOf(propertyName) + 1;
+            const schemaName = this.getSchemaName(currentSchema) || "current schema";
+            markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Property '${propertyName}' not found in ${schemaName}`));
+          }
+        }
+      }
+      const addSubMatch = trimmed.match(/^(?:add|subtract)\s+(\w+)\s+by\s+/);
+      if (addSubMatch) {
+        const currentSchema = contextStack[contextStack.length - 1];
+        if (currentSchema?.properties) {
+          const [, propertyName] = addSubMatch;
+          if (!currentSchema.properties[propertyName]) {
+            const col = line.indexOf(propertyName) + 1;
+            const schemaName = this.getSchemaName(currentSchema) || "current schema";
+            markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Property '${propertyName}' not found in ${schemaName}`));
+          }
+        }
+      }
+      const childrenMatch = trimmed.match(/^children\s+(\w+)\s+identified\s+by\s+/);
+      if (childrenMatch) {
+        const currentSchema = contextStack[contextStack.length - 1];
+        if (currentSchema?.properties) {
+          const [, propertyName] = childrenMatch;
+          const prop = currentSchema.properties[propertyName];
+          if (!prop) {
+            const col = line.indexOf(propertyName) + 1;
+            const schemaName = this.getSchemaName(currentSchema) || "current schema";
+            markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Collection property '${propertyName}' not found in ${schemaName}`));
+          } else if (prop.type !== "array" && !prop.items) {
+            const col = line.indexOf(propertyName) + 1;
+            markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Property '${propertyName}' is not a collection (array) type`));
+          } else {
+            const childSchema = prop.items;
+            if (childSchema) {
+              contextStack.push(childSchema);
+              indentStack.push(currentIndent);
+              eventContextStack.push(/* @__PURE__ */ new Map());
+            }
+          }
+        }
+      }
+      const joinMatch = trimmed.match(/^join\s+(\w+)\s+on\s+(\w+)/);
+      if (joinMatch && activeSchema?.properties) {
+        const [, collectionName, joinProperty] = joinMatch;
+        const collectionProp = activeSchema.properties[collectionName];
+        if (!collectionProp) {
+          const col = line.indexOf(collectionName) + 1;
+          markers.push(this.createWarning(lineNumber, col, col + collectionName.length, `Collection property '${collectionName}' not found in read model '${readModelName}'`));
+        } else if (collectionProp.type !== "array" && !collectionProp.items) {
+          const col = line.indexOf(collectionName) + 1;
+          markers.push(this.createWarning(lineNumber, col, col + collectionName.length, `Property '${collectionName}' is not a collection (array) type`));
+        }
+        if (!activeSchema.properties[joinProperty]) {
+          const col = line.indexOf(joinProperty, line.indexOf("on")) + 1;
+          markers.push(this.createWarning(lineNumber, col, col + joinProperty.length, `Property '${joinProperty}' not found in read model '${readModelName}'`));
+        }
+        eventContextStack.push(/* @__PURE__ */ new Map());
+        indentStack.push(currentIndent);
+      }
+      const keyMatch = trimmed.match(/^key\s+(\w+)\s*$/);
+      if (keyMatch && activeSchema) {
+        const [, keyName] = keyMatch;
+        const isInDefinitions = activeSchema.definitions && activeSchema.definitions[keyName];
+        const isProperty = activeSchema.properties && activeSchema.properties[keyName];
+        if (!isInDefinitions && !isProperty && !this.isBuiltInExpression(keyName)) {
+          const col = line.indexOf(keyName) + 1;
+          markers.push(this.createWarning(lineNumber, col, col + keyName.length, `Composite key type '${keyName}' not found in read model schema`));
+        }
+      }
+    }
+    for (const issue of validateEventContextPaths(lines, fenceMap(lines))) {
+      markers.push({
+        severity: issue.severity === "error" ? 8 : 4,
+        startLineNumber: issue.line + 1,
+        endLineNumber: issue.line + 1,
+        startColumn: issue.startColumn,
+        endColumn: issue.endColumn,
+        message: issue.message,
+        code: issue.code
+      });
+    }
+    return markers;
+  }
+  resolveReadModelInfo(readModelToken) {
+    return this.readModels.find((rm) => rm.identifier === readModelToken || rm.displayName === readModelToken) || null;
+  }
+  getReadModelStartColumn(firstLine, readModelName) {
+    const prefixMatch = firstLine.match(/^\s*projection\s+[\w.]+\s*=>\s*/);
+    if (!prefixMatch) {
+      const fallbackIndex = firstLine.lastIndexOf(readModelName);
+      return (fallbackIndex >= 0 ? fallbackIndex : 0) + 1;
+    }
+    return prefixMatch[0].length + 1;
+  }
+  resolveReadModelIdentifier(readModelToken) {
+    if (this.isDraftReadModel(readModelToken)) {
+      return this.draftReadModel.identifier;
+    }
+    const readModel = this.resolveReadModelInfo(readModelToken);
+    return readModel?.identifier ?? null;
+  }
+  isDraftReadModel(readModelToken) {
+    return !!this.draftReadModel && (this.draftReadModel.identifier === readModelToken || this.draftReadModel.displayName === readModelToken);
+  }
+  isBuiltInExpression(text) {
+    return text.startsWith("$") || ["true", "false", "null"].includes(text);
+  }
+  createError(line, startCol, endCol, message) {
+    return {
+      severity: 8,
+      // Error
+      startLineNumber: line,
+      startColumn: startCol,
+      endLineNumber: line,
+      endColumn: endCol,
+      message
+    };
+  }
+  createWarning(line, startCol, endCol, message) {
+    return {
+      severity: 4,
+      // Warning
+      startLineNumber: line,
+      startColumn: startCol,
+      endLineNumber: line,
+      endColumn: endCol,
+      message
+    };
+  }
+  createInfo(line, startCol, endCol, message) {
+    return {
+      severity: 2,
+      // Info (hint) - shows as blue/green squiggly
+      startLineNumber: line,
+      startColumn: startCol,
+      endLineNumber: line,
+      endColumn: endCol,
+      message
+    };
+  }
+  getSchemaName(schema) {
+    if (schema.name) return schema.name;
+    if (schema.title) return schema.title;
+    if (typeof schema.$id === "string") {
+      const parts = schema.$id.split("/");
+      return parts[parts.length - 1] || schema.$id;
+    }
+    return void 0;
+  }
+};
+
+// sub-languages/projection/HoverProvider.ts
+var HoverProvider = class {
+  readModels = [];
+  eventSchemas = {};
+  draftReadModel = null;
+  setReadModels(readModels) {
+    this.readModels = readModels || [];
+  }
+  // Keep for backwards compatibility
+  setReadModelSchemas(schemas) {
+    this.readModels = schemas.map((schema) => ({
+      identifier: this.getSchemaName(schema) || "",
+      displayName: this.getSchemaName(schema) || "",
+      schema
+    }));
+  }
+  setEventSchemas(schemas) {
+    if (!schemas) {
+      this.eventSchemas = {};
+      return;
+    }
+    if (Array.isArray(schemas)) {
+      const map = {};
+      schemas.forEach((s, i) => {
+        if (!s) return;
+        const name = this.getSchemaName(s) || `Event${i + 1}`;
+        map[name] = s;
+      });
+      this.eventSchemas = map;
+      return;
+    }
+    this.eventSchemas = schemas;
+  }
+  setDraftReadModel(draft) {
+    this.draftReadModel = draft;
+  }
+  provideHover(model, position) {
+    const word = model.getWordAtPosition(position);
+    if (!word) return null;
+    const wordText = word.word;
+    const lineContent = model.getLineContent(position.lineNumber);
+    const projectionNameMatch = this.getProjectionNameAtPosition(lineContent, position.column);
+    if (projectionNameMatch) {
+      return {
+        contents: [{ value: "The name of the projection" }],
+        range: {
+          startLineNumber: position.lineNumber,
+          startColumn: word.startColumn,
+          endLineNumber: position.lineNumber,
+          endColumn: word.endColumn
+        }
+      };
+    }
+    const eventContextInfo = this.getEventContextInfo(lineContent, word.startColumn);
+    if (eventContextInfo) {
+      return {
+        contents: [{ value: eventContextInfo }],
+        range: {
+          startLineNumber: position.lineNumber,
+          startColumn: word.startColumn,
+          endLineNumber: position.lineNumber,
+          endColumn: word.endColumn
+        }
+      };
+    }
+    const keywordInfo = this.getKeywordInfo(wordText);
+    if (keywordInfo) {
+      return {
+        contents: [{ value: keywordInfo }],
+        range: {
+          startLineNumber: position.lineNumber,
+          startColumn: word.startColumn,
+          endLineNumber: position.lineNumber,
+          endColumn: word.endColumn
+        }
+      };
+    }
+    const expressionInfo = this.getExpressionInfo(wordText);
+    if (expressionInfo) {
+      return {
+        contents: [{ value: expressionInfo }],
+        range: {
+          startLineNumber: position.lineNumber,
+          startColumn: word.startColumn,
+          endLineNumber: position.lineNumber,
+          endColumn: word.endColumn
+        }
+      };
+    }
+    if (this.eventSchemas[wordText]) {
+      const schema = this.eventSchemas[wordText];
+      const description = this.getSchemaDescription(schema);
+      const properties = this.getSchemaProperties(schema);
+      let content = `**Event Type:** \`${wordText}\`
+
+`;
+      if (description) {
+        content += `${description}
+
+`;
+      }
+      if (properties.length > 0) {
+        content += `**Properties:**
+
+${properties.map((p) => `- \`${p.name}\`: ${p.type}`).join("\n")}`;
+      }
+      return {
+        contents: [{ value: content }],
+        range: {
+          startLineNumber: position.lineNumber,
+          startColumn: word.startColumn,
+          endLineNumber: position.lineNumber,
+          endColumn: word.endColumn
+        }
+      };
+    }
+    if (this.isDraftReadModel(wordText)) {
+      const description = this.getSchemaDescription(this.draftReadModel.schema);
+      const properties = this.getSchemaProperties(this.draftReadModel.schema);
+      const identifier = this.draftReadModel.identifier;
+      const displayName = this.draftReadModel.displayName;
+      let content = `**Read Model (Draft):** \`${displayName}\`
+
+**Identifier:** \`${identifier}\`
+
+`;
+      if (description) {
+        content += `${description}
+
+`;
+      }
+      if (properties.length > 0) {
+        content += `**Properties:**
+
+${properties.map((p) => `- \`${p.name}\`: ${p.type}`).join("\n")}`;
+      }
+      return {
+        contents: [{ value: content }],
+        range: {
+          startLineNumber: position.lineNumber,
+          startColumn: word.startColumn,
+          endLineNumber: position.lineNumber,
+          endColumn: word.endColumn
+        }
+      };
+    }
+    const readModel = this.resolveReadModelInfo(wordText);
+    if (readModel) {
+      const description = this.getSchemaDescription(readModel.schema);
+      const properties = this.getSchemaProperties(readModel.schema);
+      let content = `**Read Model:** \`${readModel.displayName}\`
+
+**Identifier:** \`${readModel.identifier}\`
+
+`;
+      if (description) {
+        content += `${description}
+
+`;
+      }
+      if (properties.length > 0) {
+        content += `**Properties:**
+
+${properties.map((p) => `- \`${p.name}\`: ${p.type}`).join("\n")}`;
+      }
+      return {
+        contents: [{ value: content }],
+        range: {
+          startLineNumber: position.lineNumber,
+          startColumn: word.startColumn,
+          endLineNumber: position.lineNumber,
+          endColumn: word.endColumn
+        }
+      };
+    }
+    const propertyInfo = this.getPropertyInfo(model, position, wordText);
+    if (propertyInfo) {
+      return {
+        contents: [{ value: propertyInfo }],
+        range: {
+          startLineNumber: position.lineNumber,
+          startColumn: word.startColumn,
+          endLineNumber: position.lineNumber,
+          endColumn: word.endColumn
+        }
+      };
+    }
+    return null;
+  }
+  getKeywordInfo(word) {
+    const keywords = {
+      "projection": "**projection** - Defines a projection that transforms events into a read model",
+      "from": "**from** *<EventType>*\n\nHandles specific event types and maps their properties to the read model.",
+      "all": "**all**\n\nSubscribes to **all event types in the system**, regardless of explicit `from` blocks. Mappings inside `all` run for every event that arrives system-wide.",
+      "every": "**every**\n\nHandles all events the projection **explicitly subscribes to** through `from` blocks, with automatic property mapping.",
+      "key": "**key** *<expression>*\n\nDefines the projection key or composite key type.",
+      "parent": "**parent** *<expression>*\n\nDefines a parent relationship for hierarchical projections.",
+      "join": "**join** *<collection>* **on** *<property>*\n\nJoins with a child collection based on a property.",
+      "children": "**children** *<collection>* **id** *<expression>*\n\nDefines operations on child collections.",
+      "remove": "**remove with** *<EventType>* or **remove via join on** *<EventType>*\n\nRemoves items from the read model based on events.",
+      "clear": "**clear** *<property>*\n\nRemoves the value a property holds. **clear with** *<EventType>* nulls a whole nested object instead.",
+      "automap": "**automap** or **no automap**\n\nControls automatic property mapping from events to the read model.",
+      "increment": "**increment** *<property>*\n\nIncrements a numeric property by 1.",
+      "decrement": "**decrement** *<property>*\n\nDecrements a numeric property by 1.",
+      "count": "**count** *<property>*\n\nCounts occurrences and stores in a property.",
+      "add": "**add** *<property>* **by** *<expression>*\n\nAdds a value to a property.",
+      "subtract": "**subtract** *<property>* **by** *<expression>*\n\nSubtracts a value from a property.",
+      "exclude": "**exclude children**\n\nExcludes child collections from automatic mapping.",
+      "events": "**events** *<EventType>*, ...\n\nSpecifies which event types to include in a join.",
+      "via": "Used with **remove via join on** to remove items via a join relationship.",
+      "with": "Used with **remove with** to specify which event type triggers removal.",
+      "on": "Used with **join** to specify the join property.",
+      "by": "Used with **add** or **subtract** to specify the value.",
+      "id": "Used with **children** to specify the child identifier expression.",
+      "no": "Used with **no automap** to disable automatic property mapping.",
+      "variant": "**variant** *<Name>*\n\nDeclares one of several mutually exclusive named read models sharing the projection's identity. Entering one variant removes the entity from every other variant of the same projection.",
+      "enters": "**enters on** *<EventType>*\n\nDeclares the event that activates this variant - the only event allowed to create it. Every other event the variant subscribes to is update-only."
+    };
+    return keywords[word] || null;
+  }
+  getExpressionInfo(word) {
+    const expressions = {
+      "$eventSourceId": "**$eventSourceId**\n\nThe identifier of the event source (aggregate/entity) that generated the event.",
+      "$causedBy": "**$causedBy**\n\nThe identity that caused the event - `subject`, `name`, `userName` or `onBehalfOf`, itself an identity.\n\nChronicle cannot yet evaluate this short form (Cratis/Chronicle#4119); prefer **$eventContext.causedBy**.*property*.",
+      "$eventContext": describeEventContext()
+    };
+    return expressions[word] || null;
+  }
+  // Describes the $eventContext path segment starting at the given column, if the word there is one.
+  getEventContextInfo(lineContent, startColumn) {
+    for (const match of lineContent.matchAll(/\$eventContext((?:\.\w+(?:\(\))?)*)/g)) {
+      let column = (match.index ?? 0) + 1;
+      if (startColumn === column) return describeEventContext();
+      column += "$eventContext".length;
+      const segments = match[1].split(".").slice(1);
+      for (let index = 0; index < segments.length; index++) {
+        column += 1;
+        if (startColumn === column) {
+          const path = segments.slice(0, index + 1);
+          const member = eventContextMemberAt(path);
+          return member ? describeEventContextMember(path.join("."), member) : null;
+        }
+        column += segments[index].length;
+      }
+    }
+    return null;
+  }
+  getPropertyInfo(model, position, propertyName) {
+    const firstLine = model.getLineContent(1).trim();
+    const match = firstLine.match(/^projection\s+[\w.]+\s*=>\s*([\w.]+)/);
+    if (!match) return null;
+    const readModelName = match[1];
+    const draftMatch = this.isDraftReadModel(readModelName) ? this.draftReadModel : null;
+    const resolvedReadModel = draftMatch ? null : this.resolveReadModelInfo(readModelName);
+    const activeSchema = draftMatch?.schema || resolvedReadModel?.schema;
+    if (activeSchema?.properties && activeSchema.properties[propertyName]) {
+      const prop = activeSchema.properties[propertyName];
+      const type = this.getPropertyTypeDescription(prop);
+      const description = prop.description;
+      let content = `**Property:** \`${propertyName}\`
+
+**Type:** \`${type}\``;
+      if (description) {
+        content += `
+
+${description}`;
+      }
+      return content;
+    }
+    const eventType = this.getCurrentEventType(model, position.lineNumber);
+    if (eventType && this.eventSchemas[eventType]) {
+      const eventSchema = this.eventSchemas[eventType];
+      if (eventSchema.properties && eventSchema.properties[propertyName]) {
+        const prop = eventSchema.properties[propertyName];
+        const type = this.getPropertyTypeDescription(prop);
+        const description = prop.description;
+        let content = `**Event Property:** \`${propertyName}\`
+
+**Type:** \`${type}\``;
+        if (description) {
+          content += `
+
+${description}`;
+        }
+        return content;
+      }
+    }
+    return null;
+  }
+  resolveReadModelInfo(readModelToken) {
+    return this.readModels.find((rm) => rm.identifier === readModelToken || rm.displayName === readModelToken) || null;
+  }
+  isDraftReadModel(readModelToken) {
+    return !!this.draftReadModel && (this.draftReadModel.identifier === readModelToken || this.draftReadModel.displayName === readModelToken);
+  }
+  getCurrentEventType(model, lineNumber) {
+    for (let i = lineNumber; i >= 1; i--) {
+      const line = model.getLineContent(i).trim();
+      const fromMatch = line.match(/^from\s+([\w-]+)/);
+      if (fromMatch) {
+        return fromMatch[1];
+      }
+    }
+    return null;
+  }
+  getProjectionNameAtPosition(lineContent, column) {
+    const projectionMatch = lineContent.match(/^\s*projection\s+(\S+)\s*=>/);
+    if (!projectionMatch) return false;
+    const projectionKeywordEnd = lineContent.indexOf("projection") + "projection".length;
+    const arrowStart = lineContent.indexOf("=>");
+    return column > projectionKeywordEnd && column <= arrowStart;
+  }
+  getSchemaName(schema) {
+    if (schema.name) return schema.name;
+    if (schema.title) return schema.title;
+    if (typeof schema.$id === "string") {
+      const parts = schema.$id.split("/");
+      return parts[parts.length - 1] || schema.$id;
+    }
+    return void 0;
+  }
+  getSchemaDescription(schema) {
+    return schema.description || void 0;
+  }
+  getSchemaProperties(schema) {
+    if (!schema.properties) return [];
+    return Object.entries(schema.properties).map(([name, prop]) => ({
+      name,
+      type: this.getPropertyTypeDescription(prop)
+    }));
+  }
+  getPropertyTypeDescription(propSchema) {
+    if (propSchema.type === "array" && propSchema.items) {
+      const itemType = propSchema.items.type || propSchema.items.$ref?.split("/").pop() || "unknown";
+      return `${itemType}[]`;
+    }
+    return propSchema.type || propSchema.$ref?.split("/").pop() || "unknown";
+  }
+};
+
+// sub-languages/projection/CodeActionProvider.ts
+var CodeActionProvider = class {
+  readModels = [];
+  draftReadModel = null;
+  onCreateReadModel;
+  onEditReadModel;
+  setReadModels(readModels) {
+    this.readModels = readModels;
+  }
+  setDraftReadModel(draft) {
+    this.draftReadModel = draft;
+  }
+  // Keep for backwards compatibility
+  setReadModelSchemas(schemas) {
+    this.readModels = schemas.map((schema) => ({
+      identifier: schema.title || schema.name || "",
+      displayName: schema.title || schema.name || "",
+      schema
+    }));
+  }
+  setCreateReadModelCallback(callback) {
+    this.onCreateReadModel = callback;
+  }
+  setEditReadModelCallback(callback) {
+    this.onEditReadModel = callback;
+  }
+  invokeCreateReadModel(readModelName) {
+    this.onCreateReadModel?.(readModelName);
+  }
+  invokeEditReadModel(readModelName, currentSchema) {
+    this.onEditReadModel?.(readModelName, currentSchema);
+  }
+  provideCodeActions(_model, _range, context) {
+    const actions = [];
+    const notFoundDiagnostics = context.markers.filter(
+      (marker) => marker.message.includes("Read model") && marker.message.includes("not found")
+    );
+    const draftDiagnostics = context.markers.filter(
+      (marker) => marker.message.includes("Read model") && marker.message.includes("is a draft")
+    );
+    for (const diagnostic of notFoundDiagnostics) {
+      const match = diagnostic.message.match(/Read model ['"]([\w.]+)['"]/);
+      if (match && match[1]) {
+        const readModelName = match[1];
+        const existsAsPersisted = this.readModels.some(
+          (rm) => rm.identifier === readModelName || rm.displayName === readModelName
+        );
+        if (!existsAsPersisted && this.onCreateReadModel) {
+          actions.push({
+            title: `Create read model '${readModelName}'`,
+            diagnostics: [diagnostic],
+            kind: "quickfix",
+            edit: void 0,
+            isPreferred: true,
+            command: {
+              id: "pdl.createReadModel",
+              title: `Create ${readModelName}`,
+              arguments: [readModelName]
+            }
+          });
+        }
+      }
+    }
+    for (const diagnostic of draftDiagnostics) {
+      const match = diagnostic.message.match(/Read model ['"]([\w.]+)['"]/);
+      if (match && match[1]) {
+        const readModelName = match[1];
+        if (this.draftReadModel && this.isDraftReadModel(readModelName) && this.onEditReadModel) {
+          actions.push({
+            title: `Edit read model '${readModelName}'`,
+            diagnostics: [diagnostic],
+            kind: "quickfix",
+            edit: void 0,
+            isPreferred: true,
+            command: {
+              id: "pdl.editReadModel",
+              title: `Edit ${readModelName}`,
+              arguments: [readModelName, this.draftReadModel.schema]
+            }
+          });
+        }
+      }
+    }
+    return {
+      actions,
+      dispose: () => {
+      }
+    };
+  }
+  isDraftReadModel(readModelToken) {
+    return !!this.draftReadModel && (this.draftReadModel.identifier === readModelToken || this.draftReadModel.displayName === readModelToken);
+  }
+};
+
+// sub-languages/projection/index.ts
+var validator;
+var completionProvider;
+var hoverProvider;
+var codeActionProvider;
+var disposables = [];
+var monacoInstance = null;
+var isRegistered = false;
+var pendingCreateReadModelCallback = null;
+var pendingEditReadModelCallback = null;
+function registerProjectionLanguage(monaco) {
+  if (!isRegistered) {
+    isRegistered = true;
+    monacoInstance = monaco;
+    monaco.languages.register({ id: languageId });
+    monaco.languages.setLanguageConfiguration(languageId, configuration);
+    monaco.languages.setMonarchTokensProvider(languageId, monarchLanguage);
+    validator = new Validator();
+    completionProvider = new CompletionProvider();
+    hoverProvider = new HoverProvider();
+    codeActionProvider = new CodeActionProvider();
+    if (pendingCreateReadModelCallback) {
+      codeActionProvider.setCreateReadModelCallback(pendingCreateReadModelCallback);
+      pendingCreateReadModelCallback = null;
+    }
+    if (pendingEditReadModelCallback) {
+      codeActionProvider.setEditReadModelCallback(pendingEditReadModelCallback);
+      pendingEditReadModelCallback = null;
+    }
+    disposables.push(monaco.languages.registerCompletionItemProvider(languageId, {
+      provideCompletionItems: completionProvider.provideCompletionItems.bind(completionProvider),
+      triggerCharacters: [".", " ", "=", "\n", "$"]
+    }));
+    disposables.push(monaco.languages.registerHoverProvider(languageId, {
+      provideHover: hoverProvider.provideHover.bind(hoverProvider)
+    }));
+    disposables.push(monaco.languages.registerCodeActionProvider(languageId, {
+      provideCodeActions: codeActionProvider.provideCodeActions.bind(codeActionProvider)
+    }, {
+      providedCodeActionKinds: ["quickfix"]
+    }));
+    disposables.push(monaco.editor.registerCommand("pdl.createReadModel", (_accessor, readModelName) => {
+      codeActionProvider?.invokeCreateReadModel(readModelName);
+    }));
+    disposables.push(monaco.editor.registerCommand("pdl.editReadModel", (_accessor, readModelName, currentSchema) => {
+      codeActionProvider?.invokeEditReadModel(readModelName, currentSchema);
+    }));
+    disposables.push(monaco.editor.onDidCreateModel((model) => {
+      if (model.getLanguageId() === languageId) {
+        validateModel(monaco, model);
+        disposables.push(model.onDidChangeContent(() => validateModel(monaco, model)));
+      }
+    }));
+    monaco.editor.getModels().forEach((model) => {
+      if (model.getLanguageId() === languageId) {
+        validateModel(monaco, model);
+      }
+    });
+  }
+  return { dispose };
+}
+function dispose() {
+  disposables.forEach((disposable) => disposable.dispose());
+  disposables = [];
+  isRegistered = false;
+  monacoInstance = null;
+}
+function setReadModelSchema(schema) {
+  validator?.setReadModelSchemas([schema]);
+  completionProvider?.setReadModelSchemas([schema]);
+}
+function setReadModelSchemas(readModels) {
+  validator?.setReadModels(readModels);
+  completionProvider?.setReadModels(readModels);
+  hoverProvider?.setReadModels(readModels);
+  codeActionProvider?.setReadModels(readModels);
+  revalidateAllModels();
+}
+function setCreateReadModelCallback(callback) {
+  if (codeActionProvider) {
+    codeActionProvider.setCreateReadModelCallback(callback);
+  } else {
+    pendingCreateReadModelCallback = callback;
+  }
+}
+function setEditReadModelCallback(callback) {
+  if (codeActionProvider) {
+    codeActionProvider.setEditReadModelCallback(callback);
+  } else {
+    pendingEditReadModelCallback = callback;
+  }
+}
+function setDraftReadModel(draft) {
+  codeActionProvider?.setDraftReadModel(draft);
+  validator?.setDraftReadModel(draft);
+  hoverProvider?.setDraftReadModel(draft);
+  revalidateAllModels();
+}
+function setEventSchemas(eventSchemas) {
+  const normalize = (input) => {
+    if (!input) return {};
+    if (Array.isArray(input)) {
+      const out = {};
+      input.forEach((s, i) => {
+        if (!s) return;
+        const name = s.title || s.name || (typeof s.$id === "string" ? s.$id.split("/").pop() : void 0) || `Event${i + 1}`;
+        out[name] = s;
+      });
+      return out;
+    }
+    return input;
+  };
+  const normalized = normalize(eventSchemas);
+  validator?.setEventSchemas(normalized);
+  completionProvider?.setEventSchemas(normalized);
+  hoverProvider?.setEventSchemas(normalized);
+  revalidateAllModels();
+}
+function setEventSequences(sequences) {
+  completionProvider?.setEventSequences(sequences);
+}
+function validateModel(monaco, model) {
+  if (validator && !model.isDisposed()) {
+    const markers = validator.validate(model);
+    monaco.editor.setModelMarkers(model, "pdl-validator", markers);
+  }
+}
+function revalidateAllModels() {
+  if (monacoInstance) {
+    monacoInstance.editor.getModels().forEach((model) => {
+      if (model.getLanguageId() === languageId) {
+        validateModel(monacoInstance, model);
+      }
+    });
+  }
+}
+export {
+  languageId,
+  registerProjectionLanguage,
+  setCreateReadModelCallback,
+  setDraftReadModel,
+  setEditReadModelCallback,
+  setEventSchemas,
+  setEventSequences,
+  setReadModelSchema,
+  setReadModelSchemas
+};
+//# sourceMappingURL=index.js.map