@cratis/screenplay-language 4.51.0 → 4.53.0

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

@@ -0,0 +1,677 @@
+// sub-languages/capture/language.ts
+var languageId = "cdl";
+var KEYWORDS = [
+  "capture",
+  "source",
+  "key",
+  "map",
+  "append",
+  "when",
+  "nested",
+  "children",
+  "identified",
+  "by",
+  "api",
+  "webhook",
+  "message",
+  "route",
+  "poll",
+  "path",
+  "topic",
+  "from",
+  "to",
+  "or",
+  "and",
+  "added",
+  "removed",
+  "translate",
+  "split"
+];
+var BUILTINS = [
+  "$context",
+  "$previous",
+  "$env"
+];
+var OPERATORS = ["=", "=>", "."];
+var languageConfiguration = {
+  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: /^.*(\bcapture\b\s+\S+|\bsource\b(?:\s+\w+)?|\bmap\b|\bappend\b\s+\S+|\bnested\b\s+\S+|\bchildren\b\s+\S+.*|\btranslate\b|\bsplit\b.*)\s*$/,
+    decreaseIndentPattern: /^.*\}.*$/
+  },
+  folding: {
+    offSide: true,
+    markers: {
+      start: /^\s*(capture|source|map|append|nested|children|translate|split)/,
+      end: /^\s*$/
+    }
+  },
+  wordPattern: /[$]?[a-zA-Z_][\w$-]*/
+};
+var monarchLanguage = {
+  defaultToken: "",
+  tokenPostfix: ".cdl",
+  keywords: KEYWORDS,
+  builtins: BUILTINS,
+  operators: OPERATORS,
+  symbols: /[=><!~?:&|+\-*/^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  tokenizer: {
+    root: [
+      { include: "@whitespace" },
+      [/`/, { token: "string.template", next: "@templateString" }],
+      [/\$\.(?:[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)?/, "variable"],
+      [/\$previous(?:\.[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)?/, "variable.predefined"],
+      [/\$context(?:\.(?:occurred|eventSourceId))?/, "variable.predefined"],
+      [/\$env(?:\.[A-Z_][A-Z0-9_]*)?/, "variable.predefined"],
+      [/@[a-zA-Z_$][\w$]*/, "identifier.escape"],
+      [
+        /[A-Z][a-zA-Z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": "invalid",
+            "@default": "identifier"
+          }
+        }
+      ],
+      [
+        /[a-z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@builtins": "variable.predefined",
+            "@default": "identifier"
+          }
+        }
+      ],
+      [/[{}()[\]]/, "@brackets"],
+      [/=>/, "operator.arrow"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "operator",
+            "@default": ""
+          }
+        }
+      ],
+      [/\d*\.\d+([eE][-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F]+/, "number.hex"],
+      [/\d+/, "number"],
+      [/[;,.]/, "delimiter"],
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      [/"/, { token: "string.quote", next: "@string" }]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/#.*$/, "comment"]
+    ],
+    templateString: [
+      [/\$\{/, { token: "delimiter.bracket", next: "@templateExpression" }],
+      [/[^\\`$]+/, "string.template"],
+      [/@escapes/, "string.template.escape"],
+      [/\\./, "string.template.escape.invalid"],
+      [/`/, { token: "string.template", next: "@pop" }]
+    ],
+    templateExpression: [
+      [/\}/, { token: "delimiter.bracket", next: "@pop" }],
+      { include: "@root" }
+    ],
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ]
+  }
+};
+
+// sub-languages/capture/CompletionProvider.ts
+import { languages } from "monaco-editor";
+var commonPropertyPaths = [
+  "id",
+  "status",
+  "firstName",
+  "lastName",
+  "fullName",
+  "address.street",
+  "address.city",
+  "lineItems",
+  "lineItems.quantity",
+  "lineNumber",
+  "quantity"
+];
+var CompletionProvider = class {
+  triggerCharacters = [".", " ", "=", "$"];
+  provideCompletionItems(model, position) {
+    const context = this.buildContext(model, position);
+    const suggestions = [];
+    if (context.lineNumber === 1) {
+      this.addCaptureLineCompletions(suggestions, context);
+    } else if (this.isAfterKeyword(context, "capture")) {
+      this.addCaptureNameCompletions(suggestions, context);
+    } else if (this.isAfterKeyword(context, "source")) {
+      this.addSourceTypeCompletions(suggestions, context);
+    } else if (this.isAfterAppendKeyword(context)) {
+      this.addAppendNameCompletions(suggestions, context);
+    } else if (this.isAfterWhenKeyword(context)) {
+      this.addWhenCompletions(suggestions, context);
+    } else if (this.isAfterWhenFrom(context)) {
+      this.addFromValueCompletions(suggestions, context);
+    } else if (this.isAfterWhenTo(context)) {
+      this.addToValueCompletions(suggestions, context);
+    } else if (this.isAfterContextPrefix(context, "$.")) {
+      this.addPathCompletions(suggestions, context, "$.");
+    } else if (this.isAfterContextPrefix(context, "$previous.")) {
+      this.addPathCompletions(suggestions, context, "$previous.");
+    } else if (this.isAfterContextPrefix(context, "$context.")) {
+      this.addContextCompletions(suggestions, context);
+    } else if (this.isAfterContextPrefix(context, "$env.")) {
+      this.addEnvironmentCompletions(suggestions, context);
+    } else if (this.isAfterAssignment(context)) {
+      this.addAssignmentValueCompletions(suggestions, context);
+    } else if ((this.isStartOfLine(context) || this.isAfterIndent(context)) && context.indentLevel === 1) {
+      this.addTopLevelStatementCompletions(suggestions, context);
+    } else if ((this.isStartOfLine(context) || this.isAfterIndent(context)) && context.indentLevel >= 2) {
+      this.addSourceBlockCompletions(suggestions, context, this.getCurrentSourceType(model, position.lineNumber));
+    }
+    return { suggestions };
+  }
+  buildContext(model, position) {
+    const lineContent = model.getLineContent(position.lineNumber);
+    const textBeforeCursor = lineContent.substring(0, position.column - 1);
+    const word = model.getWordUntilPosition(position);
+    return {
+      textBeforeCursor,
+      currentWord: word.word || "",
+      indentLevel: this.getIndentLevel(textBeforeCursor),
+      lineNumber: position.lineNumber,
+      wordStartColumn: word.startColumn,
+      wordEndColumn: word.endColumn
+    };
+  }
+  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);
+  }
+  isAfterAppendKeyword(context) {
+    return /\bappend\s+[\w.]*$/.test(context.textBeforeCursor);
+  }
+  isAfterWhenKeyword(context) {
+    return /\bwhen\s+[\w.]*$/.test(context.textBeforeCursor);
+  }
+  isAfterWhenFrom(context) {
+    return /\bwhen\s+[\w.]+\s+from\s+[^\s]*$/.test(context.textBeforeCursor);
+  }
+  isAfterWhenTo(context) {
+    return /\bwhen\s+[\w.]+\s+from\s+\S+\s+to\s+[^\s]*$/.test(context.textBeforeCursor);
+  }
+  isAfterAssignment(context) {
+    return /=\s*([$\w.]*)$/.test(context.textBeforeCursor);
+  }
+  isAfterContextPrefix(context, prefix) {
+    return context.textBeforeCursor.endsWith(prefix);
+  }
+  addCaptureLineCompletions(suggestions, context) {
+    const trimmed = context.textBeforeCursor.trim();
+    if (trimmed === "" || "capture".startsWith(trimmed)) {
+      suggestions.push({
+        label: "capture",
+        kind: languages.CompletionItemKind.Keyword,
+        insertText: "capture ",
+        documentation: "Define a capture declaration",
+        detail: "capture <Name>",
+        range: this.getRangeForWord(context)
+      });
+    }
+    if (trimmed.startsWith("capture ")) {
+      this.addCaptureNameCompletions(suggestions, context);
+    }
+  }
+  addCaptureNameCompletions(suggestions, context) {
+    suggestions.push({
+      label: "CaptureDefinition",
+      kind: languages.CompletionItemKind.Class,
+      insertText: "CaptureDefinition",
+      documentation: "A descriptive name for this capture declaration",
+      detail: "Capture name",
+      range: this.getRangeForWord(context)
+    });
+  }
+  addSourceTypeCompletions(suggestions, context) {
+    [
+      { label: "api", detail: "source api", documentation: "Capture data by polling an HTTP API" },
+      { label: "webhook", detail: "source webhook", documentation: "Capture data from incoming webhook requests" },
+      { label: "message", detail: "source message", documentation: "Capture data from a message topic" }
+    ].forEach((source) => {
+      suggestions.push({
+        label: source.label,
+        kind: languages.CompletionItemKind.Keyword,
+        insertText: source.label,
+        documentation: source.documentation,
+        detail: source.detail,
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  // Per source type — no `auth`/`bearer`/`url`: an API source references a named
+  // External Service (`api <ServiceName>`) for base URL and auth; a webhook source's
+  // authentication is configured on the source builder, not in CDL text.
+  addSourceBlockCompletions(suggestions, context, sourceType) {
+    const options = {
+      api: [
+        { label: "api", detail: "api <ServiceName>", documentation: "References a configured External Service by name for the base URL and authentication" },
+        { label: "route", detail: "route <path>", documentation: "Optional path appended to the External Service base URL; if omitted, the base URL is used as-is" },
+        { label: "poll", detail: "poll <interval>", documentation: "The polling interval, for example 5m" }
+      ],
+      webhook: [
+        { label: "path", detail: "path <route>", documentation: "The inbound path this webhook listens on" }
+      ],
+      message: [
+        { label: "topic", detail: "topic <name>", documentation: "The topic or subject to subscribe to" }
+      ]
+    };
+    (sourceType ? options[sourceType] ?? [] : []).forEach((option) => {
+      suggestions.push({
+        label: option.label,
+        kind: languages.CompletionItemKind.Keyword,
+        insertText: `${option.label} `,
+        documentation: option.documentation,
+        detail: option.detail,
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  addTopLevelStatementCompletions(suggestions, context) {
+    [
+      { label: "key", insertText: "key ", detail: "key <property>", documentation: "Identify the captured entity" },
+      { label: "map", insertText: "map", detail: "map", documentation: "Map captured fields into a normalized shape" },
+      { label: "append", insertText: "append ", detail: "append <EventName>", documentation: "Append an event when a condition matches" },
+      { label: "nested", insertText: "nested ", detail: "nested <property>", documentation: "Create a nested mapping scope" },
+      { label: "children", insertText: "children ", detail: "children <collection> identified by <property>", documentation: "Handle child collections independently" }
+    ].forEach((statement) => {
+      suggestions.push({
+        label: statement.label,
+        kind: languages.CompletionItemKind.Keyword,
+        insertText: statement.insertText,
+        documentation: statement.documentation,
+        detail: statement.detail,
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  addAppendNameCompletions(suggestions, context) {
+    suggestions.push({
+      label: "ItemChanged",
+      kind: languages.CompletionItemKind.Class,
+      insertText: "ItemChanged",
+      documentation: "A generic event name for the appended event",
+      detail: "Event name",
+      range: this.getRangeForWord(context)
+    });
+  }
+  addWhenCompletions(suggestions, context) {
+    [
+      { label: "added", insertText: "added", detail: "when added", documentation: "Append when a child item was added" },
+      { label: "removed", insertText: "removed", detail: "when removed", documentation: "Append when a child item was removed" },
+      { label: "status", insertText: "status", detail: "when <property>", documentation: "Append when a property changed" },
+      { label: "status transition", insertText: "status from inactive to active", detail: "when <property> from <value> to <value>", documentation: "Append when a property changed between two values" },
+      { label: "quantity", insertText: "quantity", detail: "when <property>", documentation: "Append when a property changed" },
+      { label: "lineNumber", insertText: "lineNumber", detail: "when <property>", documentation: "Append when a specific property changed" }
+    ].forEach((option) => {
+      suggestions.push({
+        label: option.label,
+        kind: languages.CompletionItemKind.Keyword,
+        insertText: option.insertText,
+        documentation: option.documentation,
+        detail: option.detail,
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  addFromValueCompletions(suggestions, context) {
+    [
+      { label: "*", insertText: "*", detail: "Wildcard", documentation: "Match any previous value" },
+      { label: "inactive", insertText: "inactive", detail: "Common value", documentation: "A common previous state value" },
+      { label: "active", insertText: "active", detail: "Common value", documentation: "A common previous state value" },
+      { label: "true", insertText: "true", detail: "Boolean value", documentation: "Boolean true" },
+      { label: "false", insertText: "false", detail: "Boolean value", documentation: "Boolean false" }
+    ].forEach((option) => {
+      suggestions.push({
+        label: option.label,
+        kind: languages.CompletionItemKind.Value,
+        insertText: option.insertText,
+        documentation: option.documentation,
+        detail: option.detail,
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  addToValueCompletions(suggestions, context) {
+    ["active", "inactive", "pending", "true", "false"].forEach((value) => {
+      suggestions.push({
+        label: value,
+        kind: languages.CompletionItemKind.Value,
+        insertText: value,
+        documentation: `Common target value: ${value}`,
+        detail: "Target value",
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  addAssignmentValueCompletions(suggestions, context) {
+    [
+      { label: "$.", insertText: "$.", detail: "Current captured value", documentation: "Reference the current captured payload" },
+      { label: "$previous.", insertText: "$previous.", detail: "Previous captured value", documentation: "Reference the previous state of the payload" },
+      { label: "$context.occurred", insertText: "$context.occurred", detail: "Occurred timestamp", documentation: "When the capture source produced the current data" },
+      { label: "$context.eventSourceId", insertText: "$context.eventSourceId", detail: "Event source identifier", documentation: "The resolved event source identifier for the append operation" },
+      { label: "$env.", insertText: "$env.", detail: "Environment variable", documentation: "Read an environment variable" }
+    ].forEach((option) => {
+      suggestions.push({
+        label: option.label,
+        kind: languages.CompletionItemKind.Variable,
+        insertText: option.insertText,
+        documentation: option.documentation,
+        detail: option.detail,
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  addPathCompletions(suggestions, context, prefix) {
+    commonPropertyPaths.forEach((path) => {
+      suggestions.push({
+        label: path,
+        kind: languages.CompletionItemKind.Property,
+        insertText: `${prefix}${path}`,
+        documentation: `Common property path: ${prefix}${path}`,
+        detail: prefix === "$." ? "Current value path" : "Previous value path",
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  addContextCompletions(suggestions, context) {
+    [
+      { label: "occurred", insertText: "$context.occurred", detail: "When the event occurred", documentation: "Timestamp for when the append event happened" },
+      { label: "eventSourceId", insertText: "$context.eventSourceId", detail: "Event source identifier", documentation: "The event source identifier used for the appended event" }
+    ].forEach((option) => {
+      suggestions.push({
+        label: option.label,
+        kind: languages.CompletionItemKind.Property,
+        insertText: option.insertText,
+        documentation: option.documentation,
+        detail: option.detail,
+        range: this.getRangeForWord(context)
+      });
+    });
+  }
+  addEnvironmentCompletions(suggestions, context) {
+    suggestions.push({
+      label: "API_TOKEN",
+      kind: languages.CompletionItemKind.Variable,
+      insertText: "$env.API_TOKEN",
+      documentation: "Placeholder environment variable reference",
+      detail: "Environment variable",
+      range: this.getRangeForWord(context)
+    });
+  }
+  getCurrentSourceType(model, lineNumber) {
+    for (let index = lineNumber; index >= 1; index--) {
+      const line = model.getLineContent(index).trim();
+      const match = line.match(/^source\s+(api|webhook|message)\b/);
+      if (match) {
+        return match[1];
+      }
+    }
+    return null;
+  }
+  getRangeForWord(context) {
+    return {
+      startLineNumber: context.lineNumber,
+      endLineNumber: context.lineNumber,
+      startColumn: context.wordStartColumn,
+      endColumn: context.wordEndColumn
+    };
+  }
+};
+
+// sub-languages/capture/HoverProvider.ts
+var HoverProvider = class {
+  provideHover(model, position) {
+    const token = this.getTokenAtPosition(model, position);
+    if (!token) {
+      return null;
+    }
+    const keywordInfo = this.getKeywordInfo(token.word);
+    if (keywordInfo) {
+      return {
+        contents: [{ value: keywordInfo }],
+        range: token.range
+      };
+    }
+    const expressionInfo = this.getExpressionInfo(token.word);
+    if (expressionInfo) {
+      return {
+        contents: [{ value: expressionInfo }],
+        range: token.range
+      };
+    }
+    return null;
+  }
+  getTokenAtPosition(model, position) {
+    const lineContent = model.getLineContent(position.lineNumber);
+    const tokens = [...lineContent.matchAll(/\$context|\$previous|\$env|[a-zA-Z_][\w-]*/g)];
+    const column = position.column - 1;
+    for (const token of tokens) {
+      const startIndex = token.index ?? 0;
+      const endIndex = startIndex + token[0].length;
+      if (column >= startIndex && column <= endIndex) {
+        return {
+          word: token[0],
+          range: {
+            startLineNumber: position.lineNumber,
+            endLineNumber: position.lineNumber,
+            startColumn: startIndex + 1,
+            endColumn: endIndex + 1
+          }
+        };
+      }
+    }
+    return null;
+  }
+  // No `auth`/`bearer`/`url` — removed with the grammar. `api`, `route`, `path`, and
+  // `topic` reflect the current source-property meanings (see grammar.md).
+  getKeywordInfo(word) {
+    const keywords = {
+      capture: "**capture** *<Name>*\n\nDeclares a capture and gives it a unique name.",
+      source: "**source** *<type>*\n\nDefines where the capture reads input from.",
+      key: "**key** *<property>*\n\nSelects the property used to identify each captured item.",
+      map: "**map**\n\nMaps source fields into a normalized shape for later append blocks.",
+      append: "**append** *<EventName>*\n\nDeclares an event to append when the `when` clause matches.",
+      when: "**when** *<condition>*\n\nSpecifies when an append block should fire.",
+      nested: "**nested** *<property>*\n\nCreates a nested mapping scope for an object property.",
+      children: "**children** *<collection>* **identified by** *<property>*\n\nCreates a scope for child collection items.",
+      identified: "**identified**\n\nUsed with `children` to declare how child items are identified.",
+      by: "**by**\n\nUsed in `children ... identified by`, `split ... by`, and similar clauses.",
+      api: "**api**\n\nAs a source type (`source api`): polls an HTTP API for changes.\n\nAs a source property (`api <ServiceName>`): references a configured External Service by name for the base URL and authentication.",
+      webhook: "**webhook**\n\nA source type for receiving webhook payloads.",
+      message: "**message**\n\nA source type for consuming messages from a topic.",
+      route: "**route** *<path>*\n\nOptional path appended to an API source's External Service base URL. If omitted, the base URL is used as-is.",
+      poll: "**poll** *<interval>*\n\nSets the polling interval for an API source.",
+      path: "**path** *<route>*\n\nThe inbound path a webhook source listens on.",
+      topic: "**topic** *<name>*\n\nConfigures the topic for a message source.",
+      from: "**from** *<value>*\n\nUsed in a `when` clause to match the previous value.",
+      to: "**to** *<value>*\n\nUsed in a `when` clause to match the new value.",
+      or: "**or**\n\nCombines multiple `when` conditions.",
+      and: "**and**\n\nCombines multiple `when` conditions that must all match.",
+      added: "**added**\n\nMatches when a child item was added.",
+      removed: "**removed**\n\nMatches when a child item was removed.",
+      translate: "**translate**\n\nMaps source values to new values inside a `map` block.",
+      split: "**split** *<value>* **by** *<separator>*\n\nSplits a string into multiple mapped fields."
+    };
+    return keywords[word] || null;
+  }
+  getExpressionInfo(word) {
+    const expressions = {
+      "$context": "**$context**\n\nCapture execution context.\n\n**Properties:**\n- `occurred` - When the current event should be considered to have occurred\n- `eventSourceId` - The resolved event source identifier",
+      "$previous": "**$previous**\n\nThe previous state for the captured item. Use dot notation such as `$previous.status`.",
+      "$env": "**$env**\n\nEnvironment variables. Use dot notation such as `$env.API_TOKEN`."
+    };
+    return expressions[word] || null;
+  }
+};
+
+// sub-languages/capture/Validator.ts
+var Validator = class {
+  validate(lines) {
+    const issues = [];
+    let firstNonEmptyLineIndex = -1;
+    let firstLine = "";
+    for (let index = 0; index < lines.length; index++) {
+      const trimmed = lines[index].trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        firstNonEmptyLineIndex = index;
+        firstLine = trimmed;
+        break;
+      }
+    }
+    if (!firstLine) {
+      return issues;
+    }
+    const captureMatch = firstLine.match(/^capture\s+([\w.]+)\s*$/);
+    if (!captureMatch) {
+      issues.push(this.error(firstNonEmptyLineIndex, 1, firstLine.length + 1, 'Capture definition must start with "capture <Name>"'));
+      return issues;
+    }
+    const meaningfulLines = lines.map((line, index) => ({
+      line,
+      trimmed: line.trim(),
+      lineNumber: index,
+      indent: line.search(/\S/)
+    })).filter((entry) => entry.trimmed && !entry.trimmed.startsWith("#"));
+    const hasSource = meaningfulLines.some((entry) => entry.trimmed.startsWith("source "));
+    if (!hasSource) {
+      issues.push(this.error(firstNonEmptyLineIndex, 1, firstLine.length + 1, 'Capture definition must include a "source" block'));
+    }
+    const hasKey = meaningfulLines.some((entry) => entry.trimmed.startsWith("key "));
+    if (!hasKey) {
+      issues.push(this.error(firstNonEmptyLineIndex, 1, firstLine.length + 1, 'Capture definition must include a "key" declaration'));
+    }
+    for (let index = 0; index < meaningfulLines.length; index++) {
+      const current = meaningfulLines[index];
+      if (!current.trimmed.startsWith("append ")) {
+        continue;
+      }
+      let hasWhenClause = false;
+      for (let next = index + 1; next < meaningfulLines.length; next++) {
+        const candidate = meaningfulLines[next];
+        if (candidate.indent <= current.indent) {
+          break;
+        }
+        if (candidate.trimmed.startsWith("when ")) {
+          hasWhenClause = true;
+          break;
+        }
+      }
+      if (!hasWhenClause) {
+        const eventName = current.trimmed.substring("append ".length).trim() || "unnamed append block";
+        const startColumn = current.line.indexOf(eventName) + 1;
+        issues.push(this.error(
+          current.lineNumber,
+          startColumn > 0 ? startColumn : 1,
+          startColumn > 0 ? startColumn + eventName.length : current.line.length + 1,
+          `Append block '${eventName}' must include a "when" clause`
+        ));
+      }
+    }
+    return issues;
+  }
+  error(line, startColumn, endColumn, message) {
+    return { severity: "error", line, startColumn, endColumn, message };
+  }
+};
+
+// sub-languages/capture/index.ts
+var markerOwner = "cdl-validator";
+var disposersByMonaco = /* @__PURE__ */ new Map();
+function toMarkers(monaco, validator, model) {
+  return validator.validate(model.getLinesContent()).map((issue) => ({
+    severity: issue.severity === "error" ? monaco.MarkerSeverity.Error : monaco.MarkerSeverity.Warning,
+    message: issue.message,
+    startLineNumber: issue.line + 1,
+    startColumn: issue.startColumn,
+    endLineNumber: issue.line + 1,
+    endColumn: issue.endColumn
+  }));
+}
+function registerCaptureLanguage(monaco) {
+  const existing = disposersByMonaco.get(monaco);
+  if (existing) {
+    return { dispose: existing };
+  }
+  monaco.languages.register({ id: languageId });
+  monaco.languages.setLanguageConfiguration(languageId, languageConfiguration);
+  monaco.languages.setMonarchTokensProvider(languageId, monarchLanguage);
+  const validator = new Validator();
+  const disposables = [];
+  disposables.push(monaco.languages.registerCompletionItemProvider(languageId, new CompletionProvider()));
+  disposables.push(monaco.languages.registerHoverProvider(languageId, new HoverProvider()));
+  const validateModel = (model) => {
+    if (model.isDisposed() || model.getLanguageId() !== languageId) {
+      return;
+    }
+    monaco.editor.setModelMarkers(model, markerOwner, toMarkers(monaco, validator, model));
+  };
+  disposables.push(monaco.editor.onDidCreateModel((model) => {
+    if (model.getLanguageId() !== languageId) {
+      return;
+    }
+    validateModel(model);
+    disposables.push(model.onDidChangeContent(() => validateModel(model)));
+  }));
+  monaco.editor.getModels().forEach((model) => validateModel(model));
+  const dispose = () => {
+    disposables.forEach((disposable) => disposable.dispose());
+    disposables.length = 0;
+    disposersByMonaco.delete(monaco);
+  };
+  disposersByMonaco.set(monaco, dispose);
+  return { dispose };
+}
+export {
+  languageId,
+  registerCaptureLanguage
+};
+//# sourceMappingURL=index.js.map