@cratis/screenplay-language 4.52.0 → 4.53.0

package/sub-languages/projection/Validator.ts

@@ -1,441 +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 } from 'monaco-editor';
-import type { JsonSchema, ReadModelInfo, DraftReadModelInfo } from './index';
-import { fenceMap } from '../../document-context';
-import { validateEventContextPaths } from '../../validation';
-
-export class Validator {
-    private readModels: ReadModelInfo[] = [];
-    private eventSchemas: Record<string, JsonSchema> = {};
-    private draftReadModel: DraftReadModelInfo | null = null;
-
-    setReadModels(readModels: ReadModelInfo[]): void {
-        this.readModels = readModels || [];
-    }
-
-    setDraftReadModel(draft: DraftReadModelInfo | null): void {
-        this.draftReadModel = draft;
-    }
-
-    // Keep for backwards compatibility
-    setReadModelSchemas(schemas: JsonSchema[]): void {
-        this.readModels = schemas.map(schema => ({
-            identifier: this.getSchemaName(schema) || '',
-            displayName: this.getSchemaName(schema) || '',
-            schema
-        }));
-    }
-
-    setEventSchemas(schemas: Record<string, JsonSchema> | JsonSchema[]): void {
-        if (!schemas) {
-            this.eventSchemas = {};
-            return;
-        }
-
-        if (Array.isArray(schemas)) {
-            const map: Record<string, JsonSchema> = {};
-            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: editor.ITextModel): editor.IMarkerData[] {
-        const markers: editor.IMarkerData[] = [];
-        const content = model.getValue();
-
-        // Skip validation if content is empty or only whitespace
-        // This prevents spurious errors when the model is first created before content is loaded
-        if (!content.trim()) {
-            return markers;
-        }
-
-        // Normalize line endings and split
-        const lines = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
-
-        // Find the first non-empty, non-comment line
-        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) {
-            // This should not happen since we already checked for empty content above,
-            // but if it does (content is all comments), just return without error
-            return markers;
-        }
-
-        // Validate first meaningful line - projection declaration
-        // Supports both "projection Name => ReadModel" and ad hoc "projection Name"
-        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: JsonSchema | undefined;
-        let readModelName: string | null = null;
-
-        if (projectionWithReadModelMatch) {
-            readModelName = projectionWithReadModelMatch[2];
-
-            // Validate read model exists in schemas or is a draft
-            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) {
-                // Show info marker for draft read models - they exist but haven't been saved yet
-                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)`));
-            }
-
-            // Get the active read model schema for property validation (check draft first)
-            const isDraft = this.isDraftReadModel(readModelName);
-            const activeReadModel = isDraft ? null : this.resolveReadModelInfo(readModelName);
-            activeSchema = isDraft ? this.draftReadModel!.schema : activeReadModel?.schema;
-        }
-        // For ad hoc projections (no read model), activeSchema stays undefined — property validation is skipped
-
-        // Validate subsequent lines
-        const contextStack: JsonSchema[] = [activeSchema!];
-        const indentStack: number[] = [0]; // Track indentation levels for context
-        let lastIndent = 0;
-
-        // Track event types at each context level to detect duplicates
-        // Each entry in the stack represents events seen at that context level
-        type EventInfo = { lineNumber: number; col: number };
-        const eventContextStack: Map<string, EventInfo>[] = [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;
-
-            // Calculate current indentation
-            const currentIndent = line.search(/\S/);
-
-            // Pop context when dedenting (exiting a children block)
-            while (currentIndent < lastIndent && indentStack.length > 1) {
-                const poppedIndent = indentStack.pop();
-                if (poppedIndent !== undefined && currentIndent < poppedIndent) {
-                    contextStack.pop();
-                    eventContextStack.pop();
-                }
-            }
-            lastIndent = currentIndent;
-
-            // Get the current event context (events seen at this level)
-            const currentEventContext = eventContextStack[eventContextStack.length - 1];
-
-            // Validate event types in from/every blocks
-            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`));
-                }
-
-                // Check for duplicate events at this level
-                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 });
-                }
-            }
-
-            // Validate variant declarations - each names its own read model, which becomes the active
-            // schema for property validation inside the block (mirrors the projection-header handling above).
-            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(new Map());
-            }
-
-            // Validate 'enters on' - the event that activates a variant. Read exactly like a 'from' block for
-            // event-existence and duplicate-at-this-level purposes.
-            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 });
-                }
-            }
-
-            // Validate event types in join/remove blocks
-            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`));
-                }
-
-                // Check for duplicate events at this level (within join blocks)
-                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`));
-                }
-
-                // Check for duplicate events at this level
-                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 });
-                }
-            }
-
-            // Validate property assignments
-            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}`));
-                    }
-                }
-            }
-
-            // Validate increment/decrement/count targets
-            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}`));
-                    }
-                }
-            }
-
-            // Validate add/subtract targets
-            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}`));
-                    }
-                }
-            }
-
-            // Validate children references
-            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 {
-                        // Push child schema onto context stack for validating nested properties
-                        const childSchema = prop.items;
-                        if (childSchema) {
-                            contextStack.push(childSchema);
-                            indentStack.push(currentIndent);
-                            // Push a new event context for the children block
-                            eventContextStack.push(new Map());
-                        }
-                    }
-                }
-            }
-
-            // Validate join references
-            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}'`));
-                }
-
-                // Push a new event context for the join block
-                eventContextStack.push(new Map());
-                indentStack.push(currentIndent);
-            }
-
-            // Validate key references for composite keys
-            const keyMatch = trimmed.match(/^key\s+(\w+)\s*$/);
-            if (keyMatch && activeSchema) {
-                const [, keyName] = keyMatch;
-                // Check if it's a composite key type (should exist in definitions or as a property)
-                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`));
-                }
-            }
-        }
-
-        // Share the host's event-context path checks and catalog resolution, including dynamic dictionary keys.
-        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;
-    }
-
-    private resolveReadModelInfo(readModelToken: string): ReadModelInfo | null {
-        return this.readModels.find(rm => rm.identifier === readModelToken || rm.displayName === readModelToken) || null;
-    }
-
-    private getReadModelStartColumn(firstLine: string, readModelName: string): number {
-        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;
-    }
-
-    private resolveReadModelIdentifier(readModelToken: string): string | null {
-        if (this.isDraftReadModel(readModelToken)) {
-            return this.draftReadModel!.identifier;
-        }
-        const readModel = this.resolveReadModelInfo(readModelToken);
-        return readModel?.identifier ?? null;
-    }
-
-    private isDraftReadModel(readModelToken: string): boolean {
-        return !!this.draftReadModel && (this.draftReadModel.identifier === readModelToken || this.draftReadModel.displayName === readModelToken);
-    }
-
-    private isBuiltInExpression(text: string): boolean {
-        return text.startsWith('$') || ['true', 'false', 'null'].includes(text);
-    }
-
-    private createError(line: number, startCol: number, endCol: number, message: string): editor.IMarkerData {
-        return {
-            severity: 8, // Error
-            startLineNumber: line,
-            startColumn: startCol,
-            endLineNumber: line,
-            endColumn: endCol,
-            message,
-        };
-    }
-
-    private createWarning(line: number, startCol: number, endCol: number, message: string): editor.IMarkerData {
-        return {
-            severity: 4, // Warning
-            startLineNumber: line,
-            startColumn: startCol,
-            endLineNumber: line,
-            endColumn: endCol,
-            message,
-        };
-    }
-
-    private createInfo(line: number, startCol: number, endCol: number, message: string): editor.IMarkerData {
-        return {
-            severity: 2, // Info (hint) - shows as blue/green squiggly
-            startLineNumber: line,
-            startColumn: startCol,
-            endLineNumber: line,
-            endColumn: endCol,
-            message,
-        };
-    }
-
-    private getSchemaName(schema: JsonSchema): string | undefined {
-        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 undefined;
-    }
-}

package/sub-languages/projection/index.ts

@@ -1,223 +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 * as Monaco from 'monaco-editor';
-import { configuration, languageId, monarchLanguage } from './language';
-import { CompletionProvider } from './CompletionProvider';
-import { Validator } from './Validator';
-import { HoverProvider } from './HoverProvider';
-import { CodeActionProvider } from './CodeActionProvider';
-
-export interface JsonSchema {
-    title?: string;
-    name?: string;
-    $id?: string;
-    $ref?: string;
-    type?: string;
-    format?: string;
-    description?: string;
-    properties?: Record<string, JsonSchemaProperty>;
-    items?: JsonSchema;
-    required?: string[];
-    definitions?: Record<string, JsonSchema>;
-}
-
-export interface JsonSchemaProperty {
-    id?: string;
-    name?: string;
-    type?: string;
-    format?: string;
-    description?: string;
-    items?: JsonSchema;
-    properties?: Record<string, JsonSchemaProperty>;
-    required?: boolean;
-    $ref?: string;
-}
-
-export interface ReadModelInfo {
-    identifier: string;
-    displayName: string;
-    schema: JsonSchema;
-}
-
-// Kept as its own type (rather than duplicated inline in the validator and code action
-// provider, as the Chronicle original had it) since both consume the exact same shape.
-export interface DraftReadModelInfo {
-    identifier: string;
-    displayName: string;
-    containerName: string;
-    schema: JsonSchema;
-}
-
-let validator: Validator | undefined;
-let completionProvider: CompletionProvider | undefined;
-let hoverProvider: HoverProvider | undefined;
-let codeActionProvider: CodeActionProvider | undefined;
-let disposables: Monaco.IDisposable[] = [];
-let monacoInstance: typeof Monaco | null = null;
-let isRegistered = false;
-let pendingCreateReadModelCallback: ((readModelName: string) => void) | null = null;
-let pendingEditReadModelCallback: ((readModelName: string, currentSchema: JsonSchema) => void) | null = null;
-
-export function registerProjectionLanguage(monaco: typeof Monaco): { dispose(): void } {
-    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();
-
-        // Apply pending callbacks if they were set before initialization
-        if (pendingCreateReadModelCallback) {
-            codeActionProvider.setCreateReadModelCallback(pendingCreateReadModelCallback);
-            pendingCreateReadModelCallback = null;
-        }
-        if (pendingEditReadModelCallback) {
-            codeActionProvider.setEditReadModelCallback(pendingEditReadModelCallback);
-            pendingEditReadModelCallback = null;
-        }
-
-        // Register completion provider with helpful trigger characters
-        disposables.push(monaco.languages.registerCompletionItemProvider(languageId, {
-            provideCompletionItems: completionProvider.provideCompletionItems.bind(completionProvider),
-            triggerCharacters: ['.', ' ', '=', '\n', '$'],
-        }));
-
-        // Register hover provider
-        disposables.push(monaco.languages.registerHoverProvider(languageId, {
-            provideHover: hoverProvider.provideHover.bind(hoverProvider),
-        }));
-
-        // Register code action provider
-        disposables.push(monaco.languages.registerCodeActionProvider(languageId, {
-            provideCodeActions: codeActionProvider.provideCodeActions.bind(codeActionProvider),
-        }, {
-            providedCodeActionKinds: ['quickfix']
-        }));
-
-        // Register command for creating read models
-        disposables.push(monaco.editor.registerCommand('pdl.createReadModel', (_accessor: unknown, readModelName: string) => {
-            codeActionProvider?.invokeCreateReadModel(readModelName);
-        }));
-
-        // Register command for editing read models
-        disposables.push(monaco.editor.registerCommand('pdl.editReadModel', (_accessor: unknown, readModelName: string, currentSchema: JsonSchema) => {
-            codeActionProvider?.invokeEditReadModel(readModelName, currentSchema);
-        }));
-
-        // Register validation on model change
-        disposables.push(monaco.editor.onDidCreateModel((model: Monaco.editor.ITextModel) => {
-            if (model.getLanguageId() === languageId) {
-                validateModel(monaco, model);
-                disposables.push(model.onDidChangeContent(() => validateModel(monaco, model)));
-            }
-        }));
-
-        // Validate existing models
-        monaco.editor.getModels().forEach((model: Monaco.editor.ITextModel) => {
-            if (model.getLanguageId() === languageId) {
-                validateModel(monaco, model);
-            }
-        });
-    }
-
-    return { dispose };
-}
-
-function dispose(): void {
-    disposables.forEach((disposable) => disposable.dispose());
-    disposables = [];
-    isRegistered = false;
-    monacoInstance = null;
-}
-
-export function setReadModelSchema(schema: JsonSchema): void {
-    // Backwards compatible single-schema setter
-    validator?.setReadModelSchemas([schema]);
-    completionProvider?.setReadModelSchemas([schema]);
-}
-
-export function setReadModelSchemas(readModels: ReadModelInfo[]): void {
-    validator?.setReadModels(readModels);
-    completionProvider?.setReadModels(readModels);
-    hoverProvider?.setReadModels(readModels);
-    codeActionProvider?.setReadModels(readModels);
-    revalidateAllModels();
-}
-
-export function setCreateReadModelCallback(callback: (readModelName: string) => void): void {
-    if (codeActionProvider) {
-        codeActionProvider.setCreateReadModelCallback(callback);
-    } else {
-        // Store callback for later when the provider is initialized
-        pendingCreateReadModelCallback = callback;
-    }
-}
-
-export function setEditReadModelCallback(callback: (readModelName: string, currentSchema: JsonSchema) => void): void {
-    if (codeActionProvider) {
-        codeActionProvider.setEditReadModelCallback(callback);
-    } else {
-        // Store callback for later when the provider is initialized
-        pendingEditReadModelCallback = callback;
-    }
-}
-
-export function setDraftReadModel(draft: DraftReadModelInfo | null): void {
-    codeActionProvider?.setDraftReadModel(draft);
-    validator?.setDraftReadModel(draft);
-    hoverProvider?.setDraftReadModel(draft);
-    revalidateAllModels();
-}
-
-export function setEventSchemas(eventSchemas: JsonSchema[] | Record<string, JsonSchema>): void {
-    // Normalize either an array of schemas or a keyed record into a record keyed by derived schema name
-    const normalize = (input: JsonSchema[] | Record<string, JsonSchema>): Record<string, JsonSchema> => {
-        if (!input) return {};
-        if (Array.isArray(input)) {
-            const out: Record<string, JsonSchema> = {};
-            input.forEach((s, i) => {
-                if (!s) return;
-                const name = s.title || s.name || (typeof s.$id === 'string' ? s.$id.split('/').pop() : undefined) || `Event${i + 1}`;
-                out[name] = s;
-            });
-            return out;
-        }
-        return input;
-    };
-
-    const normalized = normalize(eventSchemas);
-    validator?.setEventSchemas(normalized);
-    completionProvider?.setEventSchemas(normalized);
-    hoverProvider?.setEventSchemas(normalized);
-    revalidateAllModels();
-}
-
-export function setEventSequences(sequences: string[]): void {
-    completionProvider?.setEventSequences(sequences);
-}
-
-function validateModel(monaco: typeof Monaco, model: Monaco.editor.ITextModel): void {
-    if (validator && !model.isDisposed()) {
-        const markers = validator.validate(model);
-        monaco.editor.setModelMarkers(model, 'pdl-validator', markers);
-    }
-}
-
-function revalidateAllModels(): void {
-    if (monacoInstance) {
-        monacoInstance.editor.getModels().forEach((model: Monaco.editor.ITextModel) => {
-            if (model.getLanguageId() === languageId) {
-                validateModel(monacoInstance!, model);
-            }
-        });
-    }
-}
-
-export { languageId };