@likec4/language-server 1.46.4 → 1.47.0

package/dist/mcp/tools/search-element.d.ts

@@ -3,6 +3,196 @@ export declare const searchElement: (languageServices: import("../..").LikeC4Lan
     inputSchema?: {
         search: z.ZodString;
     };
-}, (args: {
-    search: string;
-}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];
+}, (args: import("@modelcontextprotocol/sdk/server/zod-compat.js").ShapeOutput<{
+    search: z.ZodString;
+}>, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => {
+    [x: string]: unknown;
+    content: ({
+        type: "text";
+        text: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "audio";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        uri: string;
+        name: string;
+        type: "resource_link";
+        description?: string | undefined;
+        mimeType?: string | undefined;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        resource: {
+            uri: string;
+            text: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            uri: string;
+            blob: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    })[];
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+    structuredContent?: {
+        [x: string]: unknown;
+    } | undefined;
+    isError?: boolean | undefined;
+} | Promise<{
+    [x: string]: unknown;
+    content: ({
+        type: "text";
+        text: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "audio";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        uri: string;
+        name: string;
+        type: "resource_link";
+        description?: string | undefined;
+        mimeType?: string | undefined;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        resource: {
+            uri: string;
+            text: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            uri: string;
+            blob: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    })[];
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+    structuredContent?: {
+        [x: string]: unknown;
+    } | undefined;
+    isError?: boolean | undefined;
+}>];

package/dist/model/model-builder.d.ts

@@ -34,13 +34,15 @@ export declare class DefaultLikeC4ModelBuilder extends ADisposable implements Li
     /**
      * To avoid circular dependencies, first we parse all documents and then we join them.
      */
-    private unsafeSyncJoinedModel;
-    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownParsed> | null>;
+    private unsafeSyncJoinedModelData;
+    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownParsed>>;
     private previousViews;
     /**
      * WARNING:
      * This method is internal and should to be called only when all documents are known to be parsed.
      * Otherwise, the model may be incomplete.
+     *
+     * @internal
      */
     unsafeSyncComputeModel(projectId: c4.ProjectId, manualLayouts?: ManualLayouts): LikeC4Model<UnknownComputed>;
     computeModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownComputed>>;

package/dist/model/model-builder.js

@@ -4,7 +4,7 @@ import { LikeC4Model } from '@likec4/core/model';
 import { loggable } from '@likec4/log';
 import { deepEqual as eq } from 'fast-equals';
 import { Disposable, DocumentState, interruptAndCheck, WorkspaceCache, } from 'langium';
-import { flatMap, hasAtLeast, isEmpty, mapToObj, pipe, values, } from 'remeda';
+import { hasAtLeast, isEmpty, mapToObj, values, } from 'remeda';
 import { isLikeC4Builtin } from '../likec4lib';
 import { logger as mainLogger } from '../logger';
 import { ADisposable, performanceMark } from '../utils';
@@ -52,12 +52,9 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
      */
     unsafeSyncParseModelData(projectId) {
         const cache = this.cache;
-        const logger = builderLogger.getChild(projectId);
         const key = parsedWithoutImportsCacheKey(projectId);
-        if (cache.has(key)) {
-            logger.debug `unsafeSyncParseModelData: from cache`;
-        }
         return cache.get(key, () => {
+            const logger = builderLogger.getChild(projectId);
             try {
                 const project = this.projects.getProject(projectId);
                 const docs = this.documents(projectId);
@@ -77,50 +74,56 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
     /**
      * To avoid circular dependencies, first we parse all documents and then we join them.
      */
-    unsafeSyncJoinedModel(projectId) {
+    unsafeSyncJoinedModelData(projectId) {
         const logger = builderLogger.getChild(projectId);
-        const cache = this.cache;
-        const key = parsedModelCacheKey(projectId);
-        if (cache.has(key)) {
-            logger.debug `unsafeSyncJoinedModel from cache`;
+        const result = this.unsafeSyncParseModelData(projectId);
+        if (!result) {
+            return null;
         }
-        return cache.get(key, () => {
-            const result = this.unsafeSyncParseModelData(projectId);
-            if (!result) {
-                return null;
+        if (result.imports.size === 0) {
+            return result.data;
+        }
+        logger.debug `processing imports of ${projectId}`;
+        const imports = [...result.imports.associations()].reduce((acc, [projectId, fqns]) => {
+            if (fqns.size === 0) {
+                return acc;
             }
-            let parsedData = result.data;
-            if (result.imports.size > 0) {
-                logger.debug `processing imports of ${projectId}`;
-                const imports = [...result.imports.associations()].reduce((acc, [projectId, fqns]) => {
-                    const anotherProject = this.unsafeSyncParseModelData(projectId);
-                    if (anotherProject) {
-                        const imported = pipe([...fqns], flatMap(fqn => anotherProject.data.elements[fqn] ?? []));
-                        if (hasAtLeast(imported, 1)) {
-                            acc[projectId] = imported;
-                        }
-                    }
-                    return acc;
-                }, {});
-                parsedData = {
-                    ...result.data,
-                    imports,
-                };
-            }
-            return LikeC4Model.create(parsedData);
-        });
+            const anotherProject = this.unsafeSyncParseModelData(projectId);
+            if (anotherProject) {
+                const imported = [...fqns].flatMap(fqn => anotherProject.data.elements[fqn] ?? []);
+                if (hasAtLeast(imported, 1)) {
+                    acc[projectId] = structuredClone(imported);
+                }
+            }
+            return acc;
+        }, {});
+        return {
+            ...result.data,
+            imports,
+        };
     }
     async parseModel(projectId, cancelToken) {
         projectId = this.projects.ensureProjectId(projectId);
         const logger = builderLogger.getChild(projectId);
+        const cache = this.cache;
         const t0 = performanceMark();
         return await this.mutex.read(async () => {
             if (cancelToken?.isCancellationRequested) {
                 await interruptAndCheck(cancelToken);
             }
-            const parsedModel = this.unsafeSyncJoinedModel(projectId);
-            logger.debug `parseModel in ${t0.pretty}`;
-            return parsedModel;
+            const key = parsedModelCacheKey(projectId);
+            if (cache.has(key)) {
+                logger.debug `parseModel from cache`;
+            }
+            return cache.get(key, () => {
+                const parsedModel = this.unsafeSyncJoinedModelData(projectId);
+                if (!parsedModel) {
+                    logger.debug `parseModel: returning EMPTY`;
+                    return LikeC4Model.EMPTY.asParsed;
+                }
+                logger.debug `parseModel in ${t0.pretty}`;
+                return LikeC4Model.create(parsedModel);
+            });
         });
     }
     previousViews = {};
@@ -128,22 +131,23 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
      * WARNING:
      * This method is internal and should to be called only when all documents are known to be parsed.
      * Otherwise, the model may be incomplete.
+     *
+     * @internal
      */
     unsafeSyncComputeModel(projectId, manualLayouts) {
-        const logger = builderLogger.getChild(projectId);
         const cache = this.cache;
         const hasManualLayouts = !!manualLayouts && !isEmpty(manualLayouts);
         const key = computedModelCacheKey(projectId) + (hasManualLayouts ? '+manualLayouts' : '');
-        if (cache.has(key)) {
-            logger.debug `unsafeSyncBuildModel: from cache`;
-        }
         return cache.get(key, () => {
-            const parsedModel = this.unsafeSyncJoinedModel(projectId);
-            if (!parsedModel) {
+            const logger = builderLogger.getChild(projectId);
+            const parsedModelData = this.unsafeSyncJoinedModelData(projectId);
+            if (!parsedModelData) {
+                logger.debug `unsafeSyncComputeModel: returning EMPTY`;
                 return LikeC4Model.EMPTY.asComputed;
             }
+            const parsedModel = LikeC4Model.create(parsedModelData);
             const allViews = [];
-            for (const view of values(parsedModel.$data.views)) {
+            for (const view of values(parsedModelData.views)) {
                 const result = computeView(view, parsedModel);
                 if (!result.isSuccess) {
                     logger.warn(loggable(result.error));
@@ -165,14 +169,14 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
                 return [v.id, view];
             });
             const data = {
-                ...parsedModel.$data,
+                ...parsedModelData,
                 [_stage]: 'computed',
                 views,
             };
             if (hasManualLayouts) {
                 data.manualLayouts = manualLayouts;
             }
-            logger.debug `unsafeSyncBuildModel: completed`;
+            logger.debug(`unsafeSyncComputeModel${hasManualLayouts ? ' with manual layouts' : ''}: completed`);
             return LikeC4Model.create(data);
         });
     }
@@ -187,7 +191,12 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
             const project = this.projects.getProject(projectId);
             const manualLayouts = await this.manualLayouts.read(project);
             const result = this.unsafeSyncComputeModel(projectId, manualLayouts);
-            logger.debug(`computeModel in ${t0.pretty}`);
+            if (result === LikeC4Model.EMPTY) {
+                logger.debug(`computeModel returned EMPTY`);
+            }
+            else if (t0.ms > 10) {
+                logger.debug(`computeModel completed in ${t0.pretty}`);
+            }
             return result;
         });
     }

package/dist/model/model-parser.d.ts

@@ -13,16 +13,16 @@ declare const DocumentParserFromMixins: {
         parseGlobalDynamicPredicateGroup(astRule: import("../generated/ast").GlobalDynamicPredicateGroup): import("@likec4/core").DynamicViewIncludeRule[];
         parseGlobalStyleOrGroup(astRule: import("../generated/ast").GlobalStyle | import("../generated/ast").GlobalStyleGroup): import("@likec4/core").ElementViewRuleStyle[];
         parseViews(): void;
-        parseElementView(astNode: import("../generated/ast").ElementView, additionalStyles: (import("@likec4/core").ViewRuleGlobalStyle | import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any>)[]): import("../ast").ParsedAstElementView;
+        parseElementView(astNode: import("../generated/ast").ElementView, additionalStyles: (import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any> | import("@likec4/core").ViewRuleGlobalStyle)[]): import("../ast").ParsedAstElementView;
         parseElementViewRule(astRule: import("../generated/ast").ViewRule): import("@likec4/core").ElementViewRule;
         parseViewRulePredicate(astNode: import("../generated/ast").ViewRulePredicate): import("@likec4/core").ElementViewPredicate;
         parseViewRuleGlobalPredicateRef(astRule: import("../generated/ast").ViewRuleGlobalPredicateRef | import("../generated/ast").DynamicViewGlobalPredicateRef): import("@likec4/core").ViewRuleGlobalPredicateRef;
-        parseViewRuleStyleOrGlobalRef(astRule: import("../generated/ast").ViewRuleStyleOrGlobalRef): import("@likec4/core").ViewRuleGlobalStyle | import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any>;
+        parseViewRuleStyleOrGlobalRef(astRule: import("../generated/ast").ViewRuleStyleOrGlobalRef): import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any> | import("@likec4/core").ViewRuleGlobalStyle;
         parseViewRuleGroup(astNode: import("../generated/ast").ViewRuleGroup): import("@likec4/core").ElementViewRuleGroup;
         parseViewRuleRank(astRule: import("../generated/ast").ViewRuleRank): import("@likec4/core").ElementViewRuleRank;
         parseViewRuleStyle(astRule: import("../generated/ast").ViewRuleStyle | import("../generated/ast").GlobalStyle): import("@likec4/core").ElementViewRuleStyle;
         parseViewRuleGlobalStyle(astRule: import("../generated/ast").ViewRuleGlobalStyle): import("@likec4/core").ViewRuleGlobalStyle;
-        parseDynamicElementView(astNode: import("../generated/ast").DynamicView, additionalStyles: (import("@likec4/core").ViewRuleGlobalStyle | import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any>)[]): import("../ast").ParsedAstDynamicView;
+        parseDynamicElementView(astNode: import("../generated/ast").DynamicView, additionalStyles: (import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any> | import("@likec4/core").ViewRuleGlobalStyle)[]): import("../ast").ParsedAstDynamicView;
         parseDynamicViewRule(astRule: import("../generated/ast").DynamicViewRule): import("@likec4/core").DynamicViewRule;
         parseDynamicViewIncludePredicate(astRule: import("../generated/ast").DynamicViewIncludePredicate): import("@likec4/core").DynamicViewIncludeRule;
         parseDynamicParallelSteps(node: import("../generated/ast").DynamicViewParallelSteps): import("@likec4/core").DynamicStepsParallel;
@@ -113,16 +113,16 @@ declare const DocumentParserFromMixins: {
 } & {
     new (...args: any[]): {
         parseViews(): void;
-        parseElementView(astNode: import("../generated/ast").ElementView, additionalStyles: (import("@likec4/core").ViewRuleGlobalStyle | import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any>)[]): import("../ast").ParsedAstElementView;
+        parseElementView(astNode: import("../generated/ast").ElementView, additionalStyles: (import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any> | import("@likec4/core").ViewRuleGlobalStyle)[]): import("../ast").ParsedAstElementView;
         parseElementViewRule(astRule: import("../generated/ast").ViewRule): import("@likec4/core").ElementViewRule;
         parseViewRulePredicate(astNode: import("../generated/ast").ViewRulePredicate): import("@likec4/core").ElementViewPredicate;
         parseViewRuleGlobalPredicateRef(astRule: import("../generated/ast").ViewRuleGlobalPredicateRef | import("../generated/ast").DynamicViewGlobalPredicateRef): import("@likec4/core").ViewRuleGlobalPredicateRef;
-        parseViewRuleStyleOrGlobalRef(astRule: import("../generated/ast").ViewRuleStyleOrGlobalRef): import("@likec4/core").ViewRuleGlobalStyle | import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any>;
+        parseViewRuleStyleOrGlobalRef(astRule: import("../generated/ast").ViewRuleStyleOrGlobalRef): import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any> | import("@likec4/core").ViewRuleGlobalStyle;
         parseViewRuleGroup(astNode: import("../generated/ast").ViewRuleGroup): import("@likec4/core").ElementViewRuleGroup;
         parseViewRuleRank(astRule: import("../generated/ast").ViewRuleRank): import("@likec4/core").ElementViewRuleRank;
         parseViewRuleStyle(astRule: import("../generated/ast").ViewRuleStyle | import("../generated/ast").GlobalStyle): import("@likec4/core").ElementViewRuleStyle;
         parseViewRuleGlobalStyle(astRule: import("../generated/ast").ViewRuleGlobalStyle): import("@likec4/core").ViewRuleGlobalStyle;
-        parseDynamicElementView(astNode: import("../generated/ast").DynamicView, additionalStyles: (import("@likec4/core").ViewRuleGlobalStyle | import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any>)[]): import("../ast").ParsedAstDynamicView;
+        parseDynamicElementView(astNode: import("../generated/ast").DynamicView, additionalStyles: (import("@likec4/core").ElementViewRuleStyle<import("@likec4/core").Any> | import("@likec4/core").ViewRuleGlobalStyle)[]): import("../ast").ParsedAstDynamicView;
         parseDynamicViewRule(astRule: import("../generated/ast").DynamicViewRule): import("@likec4/core").DynamicViewRule;
         parseDynamicViewIncludePredicate(astRule: import("../generated/ast").DynamicViewIncludePredicate): import("@likec4/core").DynamicViewIncludeRule;
         parseDynamicParallelSteps(node: import("../generated/ast").DynamicViewParallelSteps): import("@likec4/core").DynamicStepsParallel;

package/dist/model/parser/Base.js

@@ -193,7 +193,12 @@ export class BaseParser {
         const { libicon, value } = prop;
         switch (true) {
             case !!libicon: {
-                return nonNullable(libicon.ref, `Library icon ${libicon.$refText} has empty ref`).name;
+                const name = libicon.ref?.name;
+                if (!name) {
+                    logger.warn(`Library icon ${libicon.$refText} is not a valid library icon`);
+                    return undefined;
+                }
+                return name;
             }
             case value && value === 'none': {
                 return value;
@@ -286,61 +291,66 @@ export class BaseParser {
             if (!this.isValid(prop)) {
                 continue;
             }
-            switch (true) {
-                case ast.isBorderProperty(prop): {
-                    if (isTruthy(prop.value)) {
-                        result.border = prop.value;
+            try {
+                switch (true) {
+                    case ast.isBorderProperty(prop): {
+                        if (isTruthy(prop.value)) {
+                            result.border = prop.value;
+                        }
+                        break;
                     }
-                    break;
-                }
-                case ast.isColorProperty(prop): {
-                    const color = toColor(prop);
-                    if (isTruthy(color)) {
-                        result.color = color;
+                    case ast.isColorProperty(prop): {
+                        const color = toColor(prop);
+                        if (isTruthy(color)) {
+                            result.color = color;
+                        }
+                        break;
                     }
-                    break;
-                }
-                case ast.isShapeProperty(prop): {
-                    if (isTruthy(prop.value)) {
-                        result.shape = prop.value;
+                    case ast.isShapeProperty(prop): {
+                        if (isTruthy(prop.value)) {
+                            result.shape = prop.value;
+                        }
+                        break;
                     }
-                    break;
-                }
-                case ast.isIconProperty(prop): {
-                    const icon = this.parseIconProperty(prop);
-                    if (isTruthy(icon)) {
-                        result.icon = icon;
+                    case ast.isIconProperty(prop): {
+                        const icon = this.parseIconProperty(prop);
+                        if (isTruthy(icon)) {
+                            result.icon = icon;
+                        }
+                        break;
                     }
-                    break;
-                }
-                case ast.isOpacityProperty(prop): {
-                    result.opacity = parseAstOpacityProperty(prop);
-                    break;
-                }
-                case ast.isMultipleProperty(prop): {
-                    result.multiple = isBoolean(prop.value) ? prop.value : false;
-                    break;
-                }
-                case ast.isShapeSizeProperty(prop): {
-                    if (isTruthy(prop.value)) {
-                        result.size = parseAstSizeValue(prop);
+                    case ast.isOpacityProperty(prop): {
+                        result.opacity = parseAstOpacityProperty(prop);
+                        break;
                     }
-                    break;
-                }
-                case ast.isPaddingSizeProperty(prop): {
-                    if (isTruthy(prop.value)) {
-                        result.padding = parseAstSizeValue(prop);
+                    case ast.isMultipleProperty(prop): {
+                        result.multiple = isBoolean(prop.value) ? prop.value : false;
+                        break;
                     }
-                    break;
-                }
-                case ast.isTextSizeProperty(prop): {
-                    if (isTruthy(prop.value)) {
-                        result.textSize = parseAstSizeValue(prop);
+                    case ast.isShapeSizeProperty(prop): {
+                        if (isTruthy(prop.value)) {
+                            result.size = parseAstSizeValue(prop);
+                        }
+                        break;
+                    }
+                    case ast.isPaddingSizeProperty(prop): {
+                        if (isTruthy(prop.value)) {
+                            result.padding = parseAstSizeValue(prop);
+                        }
+                        break;
                     }
-                    break;
+                    case ast.isTextSizeProperty(prop): {
+                        if (isTruthy(prop.value)) {
+                            result.textSize = parseAstSizeValue(prop);
+                        }
+                        break;
+                    }
+                    default:
+                        nonexhaustive(prop);
                 }
-                default:
-                    nonexhaustive(prop);
+            }
+            catch (err) {
+                logger.warn('Failed to parse style property', { err });
             }
         }
         return exact(result);

package/dist/model/parser/GlobalsParser.d.ts

@@ -9,16 +9,16 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseGlobalDynamicPredicateGroup(astRule: ast.GlobalDynamicPredicateGroup): c4.DynamicViewIncludeRule[];
         parseGlobalStyleOrGroup(astRule: ast.GlobalStyle | ast.GlobalStyleGroup): c4.ElementViewRuleStyle[];
         parseViews(): void;
-        parseElementView(astNode: ast.ElementView, additionalStyles: (c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>)[]): import("../../ast").ParsedAstElementView;
+        parseElementView(astNode: ast.ElementView, additionalStyles: (c4.ElementViewRuleStyle<c4.aux.Any> | c4.ViewRuleGlobalStyle)[]): import("../../ast").ParsedAstElementView;
         parseElementViewRule(astRule: ast.ViewRule): c4.ElementViewRule;
         parseViewRulePredicate(astNode: ast.ViewRulePredicate): c4.ElementViewPredicate;
         parseViewRuleGlobalPredicateRef(astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef): c4.ViewRuleGlobalPredicateRef;
-        parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>;
+        parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ElementViewRuleStyle<c4.aux.Any> | c4.ViewRuleGlobalStyle;
         parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ElementViewRuleGroup;
         parseViewRuleRank(astRule: ast.ViewRuleRank): c4.ElementViewRuleRank;
         parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ElementViewRuleStyle;
         parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
-        parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: (c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>)[]): import("../../ast").ParsedAstDynamicView;
+        parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: (c4.ElementViewRuleStyle<c4.aux.Any> | c4.ViewRuleGlobalStyle)[]): import("../../ast").ParsedAstDynamicView;
         parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
         parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
         parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicStepsParallel;

package/dist/model/parser/ViewsParser.js

@@ -4,7 +4,7 @@ import { loggable } from '@likec4/log';
 import { filter, find, isDefined, isEmpty, isNonNullish, isNumber, isTruthy, last, mapToObj, pipe } from 'remeda';
 import { ast, parseMarkdownAsString, toAutoLayout, toColor, ViewOps, } from '../../ast';
 import { logger as mainLogger } from '../../logger';
-import { stringHash } from '../../utils';
+import { safeCall, stringHash } from '../../utils';
 import { elementRef } from '../../utils/elementRef';
 import { parseViewManualLayout } from '../../view-utils/manual-layout';
 import { removeIndent, toSingleLine } from './Base';
@@ -62,7 +62,7 @@ export function ViewsParser(B) {
             let viewOf = null;
             if ('viewOf' in astNode) {
                 const viewOfEl = elementRef(astNode.viewOf);
-                const _viewOf = viewOfEl && this.resolveFqn(viewOfEl);
+                const _viewOf = viewOfEl && safeCall(() => this.resolveFqn(viewOfEl));
                 if (!_viewOf) {
                     const viewId = astNode.name ?? 'unnamed';
                     const msg = astNode.viewOf.$cstNode?.text ?? '<unknown>';

package/dist/protocol.d.ts

@@ -154,6 +154,11 @@ export declare namespace RegisterProject {
     type Params = {
         folderUri: URI;
         config: LikeC4ProjectJsonConfig;
+        configUri?: never;
+    } | {
+        configUri: URI;
+        folderUri?: never;
+        config?: never;
     };
     type Res = {
         id: ProjectId;

package/dist/utils/elementRef.js

@@ -3,11 +3,17 @@ import { ast } from '../ast';
  * Returns referenced AST Element
  */
 export function elementRef(node) {
-    let el = ast.isStrictFqnElementRef(node) ? node.el.ref : node.modelElement.value.ref;
-    if (el?.$type === 'Imported') {
-        el = el.imported.ref;
+    try {
+        let el = ast.isStrictFqnElementRef(node) ? node.el.ref : node.modelElement.value.ref;
+        if (el?.$type === 'Imported') {
+            el = el.imported.ref;
+        }
+        return el?.$type === 'Element' ? el : undefined;
+    }
+    catch {
+        // ignore reference errors
+        return undefined;
     }
-    return el?.$type === 'Element' ? el : undefined;
 }
 /**
  * Returns FQN of StrictFqnElementRef