@cratis/screenplay-language 4.52.0 → 4.54.0

package/sub-languages/capture/CompletionProvider.ts

@@ -1,365 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-import { languages, type editor, type Position, type IRange } from 'monaco-editor';
-
-interface CompletionContext {
-    textBeforeCursor: string;
-    currentWord: string;
-    indentLevel: number;
-    lineNumber: number;
-    wordStartColumn: number;
-    wordEndColumn: number;
-}
-
-const commonPropertyPaths = [
-    'id',
-    'status',
-    'firstName',
-    'lastName',
-    'fullName',
-    'address.street',
-    'address.city',
-    'lineItems',
-    'lineItems.quantity',
-    'lineNumber',
-    'quantity',
-];
-
-export class CompletionProvider implements languages.CompletionItemProvider {
-    triggerCharacters = ['.', ' ', '=', '$'];
-
-    provideCompletionItems(
-        model: editor.ITextModel,
-        position: Position,
-    ): languages.ProviderResult<languages.CompletionList> {
-        const context = this.buildContext(model, position);
-        const suggestions: languages.CompletionItem[] = [];
-
-        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 };
-    }
-
-    private buildContext(model: editor.ITextModel, position: Position): CompletionContext {
-        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,
-        };
-    }
-
-    private getIndentLevel(text: string): number {
-        const match = text.match(/^(\s*)/);
-        return match ? Math.floor(match[1].length / 2) : 0;
-    }
-
-    private isStartOfLine(context: CompletionContext): boolean {
-        return context.textBeforeCursor.trim() === '';
-    }
-
-    private isAfterIndent(context: CompletionContext): boolean {
-        return /^\s+$/.test(context.textBeforeCursor);
-    }
-
-    private isAfterKeyword(context: CompletionContext, keyword: string): boolean {
-        const pattern = new RegExp(`\\b${keyword}\\s+\\w*$`);
-        return pattern.test(context.textBeforeCursor);
-    }
-
-    private isAfterAppendKeyword(context: CompletionContext): boolean {
-        return /\bappend\s+[\w.]*$/.test(context.textBeforeCursor);
-    }
-
-    private isAfterWhenKeyword(context: CompletionContext): boolean {
-        return /\bwhen\s+[\w.]*$/.test(context.textBeforeCursor);
-    }
-
-    private isAfterWhenFrom(context: CompletionContext): boolean {
-        return /\bwhen\s+[\w.]+\s+from\s+[^\s]*$/.test(context.textBeforeCursor);
-    }
-
-    private isAfterWhenTo(context: CompletionContext): boolean {
-        return /\bwhen\s+[\w.]+\s+from\s+\S+\s+to\s+[^\s]*$/.test(context.textBeforeCursor);
-    }
-
-    private isAfterAssignment(context: CompletionContext): boolean {
-        return /=\s*([$\w.]*)$/.test(context.textBeforeCursor);
-    }
-
-    private isAfterContextPrefix(context: CompletionContext, prefix: string): boolean {
-        return context.textBeforeCursor.endsWith(prefix);
-    }
-
-    private addCaptureLineCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        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);
-        }
-    }
-
-    private addCaptureNameCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        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),
-        });
-    }
-
-    private addSourceTypeCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        [
-            { 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.
-    private addSourceBlockCompletions(suggestions: languages.CompletionItem[], context: CompletionContext, sourceType: string | null): void {
-        const options: Record<string, Array<{ label: string; detail: string; documentation: string }>> = {
-            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),
-            });
-        });
-    }
-
-    private addTopLevelStatementCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        [
-            { 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),
-            });
-        });
-    }
-
-    private addAppendNameCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        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),
-        });
-    }
-
-    private addWhenCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        [
-            { 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),
-            });
-        });
-    }
-
-    private addFromValueCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        [
-            { 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),
-            });
-        });
-    }
-
-    private addToValueCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        ['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),
-            });
-        });
-    }
-
-    private addAssignmentValueCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        [
-            { 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),
-            });
-        });
-    }
-
-    private addPathCompletions(suggestions: languages.CompletionItem[], context: CompletionContext, prefix: string): void {
-        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),
-            });
-        });
-    }
-
-    private addContextCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        [
-            { 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),
-            });
-        });
-    }
-
-    private addEnvironmentCompletions(suggestions: languages.CompletionItem[], context: CompletionContext): void {
-        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),
-        });
-    }
-
-    private getCurrentSourceType(model: editor.ITextModel, lineNumber: number): string | null {
-        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;
-    }
-
-    private getRangeForWord(context: CompletionContext): IRange {
-        return {
-            startLineNumber: context.lineNumber,
-            endLineNumber: context.lineNumber,
-            startColumn: context.wordStartColumn,
-            endColumn: context.wordEndColumn,
-        };
-    }
-}

package/sub-languages/capture/HoverProvider.ts

@@ -1,99 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-import type { editor, languages, Position, IRange } from 'monaco-editor';
-
-export class HoverProvider implements languages.HoverProvider {
-    provideHover(model: editor.ITextModel, position: Position): languages.ProviderResult<languages.Hover> {
-        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;
-    }
-
-    private getTokenAtPosition(model: editor.ITextModel, position: Position): { word: string; range: IRange } | null {
-        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).
-    private getKeywordInfo(word: string): string | null {
-        const keywords: Record<string, string> = {
-            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;
-    }
-
-    private getExpressionInfo(word: string): string | null {
-        const expressions: Record<string, string> = {
-            '$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;
-    }
-}

package/sub-languages/capture/Validator.ts

@@ -1,97 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-import { ValidationIssue } from '../../validation';
-
-interface MeaningfulLine {
-    line: string;
-    trimmed: string;
-    lineNumber: number;
-    indent: number;
-}
-
-// Structural rules only, unaffected by the source-property grammar changes — the
-// grammar's own syntax (see grammar.md) is what the tokenizer enforces; these are
-// the compiler's semantic constraints on top of it. Takes plain lines rather than
-// a Monaco model so it stays usable outside an editor, matching ../../validation.ts.
-export class Validator {
-    validate(lines: string[]): ValidationIssue[] {
-        const issues: ValidationIssue[] = [];
-
-        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: MeaningfulLine[] = 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;
-    }
-
-    private error(line: number, startColumn: number, endColumn: number, message: string): ValidationIssue {
-        return { severity: 'error', line, startColumn, endColumn, message };
-    }
-}

package/sub-languages/capture/index.ts

@@ -1,72 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-import type { IDisposable, editor } from 'monaco-editor';
-import { Monaco, languageConfiguration, languageId, monarchLanguage } from './language';
-import { CompletionProvider } from './CompletionProvider';
-import { HoverProvider } from './HoverProvider';
-import { Validator } from './Validator';
-
-const markerOwner = 'cdl-validator';
-
-// Keyed by Monaco instance rather than a single boolean — mirrors the composite
-// language's own registration guard (../../index.ts) and lets a second register()
-// call for the same instance hand back the existing disposer instead of doubling
-// up the completion/hover providers.
-const disposersByMonaco = new Map<Monaco, () => void>();
-
-function toMarkers(monaco: Monaco, validator: Validator, model: editor.ITextModel): editor.IMarkerData[] {
-    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,
-    }));
-}
-
-export function registerCaptureLanguage(monaco: Monaco): { dispose(): void } {
-    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: IDisposable[] = [];
-
-    disposables.push(monaco.languages.registerCompletionItemProvider(languageId, new CompletionProvider()));
-    disposables.push(monaco.languages.registerHoverProvider(languageId, new HoverProvider()));
-
-    const validateModel = (model: editor.ITextModel): void => {
-        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 = (): void => {
-        disposables.forEach((disposable) => disposable.dispose());
-        disposables.length = 0;
-        disposersByMonaco.delete(monaco);
-    };
-
-    disposersByMonaco.set(monaco, dispose);
-    return { dispose };
-}
-
-export { languageId } from './language';