@loj-lang/rdsl-compiler 0.5.0 → 0.6.0

package/dist/validator.js

@@ -10,10 +10,11 @@
  *  - Effect targets reference known resources
  *  - Required fields are present
  */
+import { lintSharedSnapshotCandidates, validateDuplicateSharedModelFieldNames, validateGeneratedPersistenceFieldNames, validateSharedCascadeFieldDecorator, validateSharedDisplayFieldTypes, validateSharedEnumFieldDecorator, validateSharedModelDisplayFieldUsage, validateSharedModelRelations, validateSharedSnapshotFieldDecorator, validateSharedSnapshotReferences, validateSharedSoftDeleteFieldNames } from '@loj-lang/shared-contracts';
 import { analyzePageBlockData } from './page-table-block.js';
 import { analyzeRelationProjection } from './relation-projection.js';
 const ROUTE_PATH_SEGMENT_PATTERN = /^(?:[A-Za-z0-9_-]+|:[A-Za-z_][A-Za-z0-9_]*)$/;
-const VALIDATION_CACHE_VERSION = '0.1.13';
+const VALIDATION_CACHE_VERSION = '0.1.16';
 export function validate(ir, options) {
     const errors = [];
     const previousCache = options?.cache?.version === VALIDATION_CACHE_VERSION
@@ -52,8 +53,10 @@ export function validate(ir, options) {
         resourceNames,
         readModelNames,
         pageNames: pageNameList,
+        shell: ir.shell ?? null,
+        routes: ir.routes ?? null,
         escapeStats: ir.escapeStats,
-    }), previousCache?.global?.core, () => validateGlobal(ir));
+    }), previousCache?.global?.core, () => validateGlobal(ir, resourceMap, pageMap));
     errors.push(...globalEntry.errors);
     const navigationEntries = ir.navigation.map((group) => resolveValidationSegment(createValidationSignature({
         targets: group.items.map((item) => item.target),
@@ -189,12 +192,13 @@ function createValidationSignature(value) {
         return normalized;
     });
 }
-function validateGlobal(ir) {
+function validateGlobal(ir, resourceMap, pageMap) {
     const errors = [];
     errors.push(...collectDuplicateErrors(ir.models, 'model'));
     errors.push(...collectDuplicateErrors(ir.resources, 'resource'));
     errors.push(...collectDuplicateErrors(ir.readModels, 'readModel'));
     errors.push(...collectDuplicateErrors(ir.pages, 'page'));
+    errors.push(...collectModelDecoratorErrors(ir.models));
     errors.push(...collectRelationErrors(ir.models));
     if (ir.escapeStats) {
         if (ir.escapeStats.overBudget) {
@@ -207,8 +211,38 @@ function validateGlobal(ir) {
             });
         }
     }
+    validateAppRoutes(ir, resourceMap, pageMap, errors);
+    validateAppShell(ir, errors);
     return errors;
 }
+function validateAppShell(ir, errors) {
+    const primaryNav = ir.shell?.navigation?.primary;
+    const secondaryNav = ir.shell?.navigation?.secondary;
+    const primaryGroups = ir.navigation.filter((group) => group.placement === 'primary');
+    const secondaryGroups = ir.navigation.filter((group) => group.placement === 'secondary');
+    if (primaryGroups.length > 0 && !primaryNav?.desktop && !primaryNav?.mobile) {
+        errors.push({
+            message: 'primary app.navigation groups are defined but app.shell.navigation.primary has no desktop/mobile placement; primary navigation will not render',
+            nodeId: ir.id,
+            severity: 'warning',
+        });
+    }
+    if (secondaryGroups.length > 0 && !secondaryNav?.desktop && !secondaryNav?.mobile) {
+        errors.push({
+            message: 'secondary app.navigation groups are defined but app.shell.navigation.secondary has no desktop/mobile placement; secondary navigation will not render',
+            nodeId: ir.id,
+            severity: 'warning',
+        });
+    }
+}
+function validateAppRoutes(ir, resourceMap, pageMap, errors) {
+    if (ir.routes?.default) {
+        validateStaticAppRouteTarget(ir.routes.default, 'app.routes.default', resourceMap, pageMap, errors, 'default');
+    }
+    if (ir.routes?.notFound) {
+        validateStaticAppRouteTarget(ir.routes.notFound, 'app.routes.notFound', resourceMap, pageMap, errors, 'notFound');
+    }
+}
 function validateReadModel(readModel) {
     const errors = [];
     if (!readModel.api) {
@@ -227,13 +261,6 @@ function validateReadModel(readModel) {
         validateReadModelField(readModel, field, resultNames, errors);
     }
     if (readModel.list) {
-        if (readModel.list.columns.length === 0) {
-            errors.push({
-                message: `Read-model "${readModel.name}" list must define at least one column`,
-                nodeId: readModel.list.id,
-                severity: 'error',
-            });
-        }
         for (const column of readModel.list.columns) {
             const resultField = readModel.result.find((field) => field.name === column.field);
             if (!resultField) {
@@ -482,9 +509,9 @@ function validateLinkedFormRules(resource, model, view, errors, mode) {
             });
         }
         seenEligibility.add(entry.name);
-        validateWorkflowExpr(entry.when, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldNames));
+        validateWorkflowExpr(entry.when, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldMap));
         for (const expr of entry.or) {
-            validateWorkflowExpr(expr, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldNames));
+            validateWorkflowExpr(expr, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldMap));
         }
     }
     const seenValidation = new Set();
@@ -497,9 +524,9 @@ function validateLinkedFormRules(resource, model, view, errors, mode) {
             });
         }
         seenValidation.add(entry.name);
-        validateWorkflowExpr(entry.when, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldNames));
+        validateWorkflowExpr(entry.when, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldMap));
         for (const expr of entry.or) {
-            validateWorkflowExpr(expr, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldNames));
+            validateWorkflowExpr(expr, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldMap));
         }
     }
     const seenDerivations = new Set();
@@ -547,9 +574,9 @@ function validateLinkedFormRules(resource, model, view, errors, mode) {
             continue;
         }
         if (entry.when) {
-            validateWorkflowExpr(entry.when, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldNames));
+            validateWorkflowExpr(entry.when, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldMap));
         }
-        validateWorkflowExpr(entry.value, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldNames));
+        validateWorkflowExpr(entry.value, rules.id, errors, (path) => validateLinkedFormRulesIdentifier(path, resource.name, mode, modelFieldMap));
     }
 }
 function validateLinkedFormIncludeRules(resource, parentModel, include, targetModel, errors, mode) {
@@ -666,48 +693,104 @@ function validateReadModelField(readModel, field, seen, errors) {
     }
 }
 function collectRelationErrors(models) {
+    return validateSharedModelRelations(models).map((issue) => ({
+        message: issue.message.replace(/^model ([^. ]+) field ([^. ]+) /, 'Field "$2" in model "$1" '),
+        nodeId: issue.nodeId,
+        severity: 'error',
+    }));
+}
+function collectModelDecoratorErrors(models) {
     const errors = [];
-    const modelMap = new Map(models.map((model) => [model.name, model]));
+    for (const issue of validateSharedModelDisplayFieldUsage(models)) {
+        errors.push({
+            message: issue.message.replace(/^model ([^. ]+) /, 'Model "$1" '),
+            nodeId: issue.nodeId,
+            severity: 'error',
+        });
+    }
+    for (const issue of validateSharedSoftDeleteFieldNames(models)) {
+        errors.push({
+            message: issue.message,
+            nodeId: issue.nodeId,
+            severity: 'error',
+        });
+    }
+    for (const issue of validateSharedDisplayFieldTypes(models)) {
+        errors.push({
+            message: issue.message,
+            nodeId: issue.nodeId,
+            severity: 'error',
+        });
+    }
+    for (const issue of validateDuplicateSharedModelFieldNames(models)) {
+        errors.push({
+            message: issue.message,
+            nodeId: issue.nodeId,
+            severity: 'error',
+        });
+    }
+    for (const issue of validateGeneratedPersistenceFieldNames(models)) {
+        errors.push({
+            message: issue.message,
+            nodeId: issue.nodeId,
+            severity: 'error',
+        });
+    }
+    for (const issue of validateSharedSnapshotReferences(models)) {
+        errors.push({
+            message: issue.message,
+            nodeId: issue.nodeId,
+            severity: issue.severity,
+        });
+    }
+    for (const issue of lintSharedSnapshotCandidates(models)) {
+        errors.push({
+            message: issue.message,
+            nodeId: issue.nodeId,
+            severity: issue.severity,
+        });
+    }
     for (const model of models) {
         for (const field of model.fields) {
-            if (field.fieldType.type !== 'relation') {
-                continue;
-            }
-            const targetModel = modelMap.get(field.fieldType.target);
-            if (!targetModel) {
-                errors.push({
-                    message: `Field "${field.name}" in model "${model.name}" references unknown relation target "${field.fieldType.target}"`,
-                    nodeId: field.id,
-                    severity: 'error',
-                });
-                continue;
+            const enumKeyPrefixDecorator = field.decorators.find((decorator) => decorator.name === 'enumKeyPrefix');
+            if (enumKeyPrefixDecorator) {
+                for (const issue of validateSharedEnumFieldDecorator(field, enumKeyPrefixDecorator)) {
+                    errors.push({
+                        message: issue.message,
+                        nodeId: issue.nodeId,
+                        severity: 'error',
+                    });
+                }
             }
-            const relationField = field.fieldType;
-            if (relationField.kind !== 'hasMany') {
+            const enumLabelsDecorator = field.decorators.find((decorator) => decorator.name === 'enumLabels');
+            if (!enumLabelsDecorator) {
                 continue;
             }
-            if (field.decorators.length > 0) {
+            for (const issue of validateSharedEnumFieldDecorator(field, enumLabelsDecorator)) {
                 errors.push({
-                    message: `Field "${field.name}" in model "${model.name}" is a hasMany() inverse relation and does not support field decorators`,
-                    nodeId: field.id,
+                    message: issue.message,
+                    nodeId: issue.nodeId,
                     severity: 'error',
                 });
             }
-            const inverseField = targetModel.fields.find((candidate) => candidate.name === relationField.by);
-            if (!inverseField) {
-                errors.push({
-                    message: `Field "${field.name}" in model "${model.name}" references missing inverse field "${relationField.by}" on model "${targetModel.name}"`,
-                    nodeId: field.id,
-                    severity: 'error',
-                });
+            const snapshotDecorator = field.decorators.find((decorator) => decorator.name === 'snapshot');
+            if (snapshotDecorator) {
+                for (const issue of validateSharedSnapshotFieldDecorator(field, snapshotDecorator)) {
+                    errors.push({
+                        message: issue.message,
+                        nodeId: issue.nodeId,
+                        severity: 'error',
+                    });
+                }
+            }
+            const cascadeDecorator = field.decorators.find((decorator) => decorator.name === 'cascade');
+            if (!cascadeDecorator) {
                 continue;
             }
-            if (inverseField.fieldType.type !== 'relation'
-                || inverseField.fieldType.kind !== 'belongsTo'
-                || inverseField.fieldType.target !== model.name) {
+            for (const issue of validateSharedCascadeFieldDecorator(field, cascadeDecorator)) {
                 errors.push({
-                    message: `Field "${field.name}" in model "${model.name}" must reference a belongsTo(${model.name}) field via by: "${relationField.by}" on model "${targetModel.name}"`,
-                    nodeId: field.id,
+                    message: issue.message,
+                    nodeId: issue.nodeId,
                     severity: 'error',
                 });
             }
@@ -715,6 +798,9 @@ function collectRelationErrors(models) {
     }
     return errors;
 }
+function hasDecorator(field, decoratorName) {
+    return field.decorators.some((decorator) => decorator.name === decoratorName);
+}
 function resolveResourceValidation(resource, modelMap, modelNames, resourceMap, resourceNames, pageNames, pageMap, pageNameList, modelFieldContext, resourceContext, previous) {
     const resourceEntry = resolveValidationSegment(createValidationSignature({
         name: resource.name,
@@ -743,6 +829,9 @@ function resolveResourceValidation(resource, modelMap, modelNames, resourceMap,
                 field: column.field,
                 customRenderer: Boolean(column.customRenderer),
             })),
+            actions: resource.views.list.actions.map((action) => action.name),
+            batchActions: resource.views.list.batchActions.map((action) => action.name),
+            messages: resource.views.list.messages ?? null,
             rules: resource.views.list.rules ?? null,
         }), previous?.list, () => validateListView(resource, modelMap.get(resource.model), resource.views.list, Array.from(modelMap.values()), Array.from(resourceMap.values())))
         : undefined;
@@ -752,8 +841,8 @@ function resolveResourceValidation(resource, modelMap, modelNames, resourceMap,
             fields: resource.views.edit.fields.map((field) => ({
                 field: field.field,
                 customField: Boolean(field.customField),
-                visibleWhen: field.visibleWhen ?? null,
-                enabledWhen: field.enabledWhen ?? null,
+                visibleIf: field.visibleIf ?? null,
+                enabledIf: field.enabledIf ?? null,
             })),
             includes: resource.views.edit.includes.map((include) => ({
                 field: include.field,
@@ -767,11 +856,12 @@ function resolveResourceValidation(resource, modelMap, modelNames, resourceMap,
                 fields: include.fields.map((field) => ({
                     field: field.field,
                     customField: Boolean(field.customField),
-                    visibleWhen: field.visibleWhen ?? null,
-                    enabledWhen: field.enabledWhen ?? null,
+                    visibleIf: field.visibleIf ?? null,
+                    enabledIf: field.enabledIf ?? null,
                 })),
             })),
             rules: resource.views.edit.rules ?? null,
+            messages: resource.views.edit.messages ?? null,
             rulesLink: resource.views.edit.rulesLink
                 ? {
                     resolvedPath: resource.views.edit.rulesLink.resolvedPath,
@@ -789,8 +879,8 @@ function resolveResourceValidation(resource, modelMap, modelNames, resourceMap,
             fields: resource.views.create.fields.map((field) => ({
                 field: field.field,
                 customField: Boolean(field.customField),
-                visibleWhen: field.visibleWhen ?? null,
-                enabledWhen: field.enabledWhen ?? null,
+                visibleIf: field.visibleIf ?? null,
+                enabledIf: field.enabledIf ?? null,
             })),
             includes: resource.views.create.includes.map((include) => ({
                 field: include.field,
@@ -804,11 +894,12 @@ function resolveResourceValidation(resource, modelMap, modelNames, resourceMap,
                 fields: include.fields.map((field) => ({
                     field: field.field,
                     customField: Boolean(field.customField),
-                    visibleWhen: field.visibleWhen ?? null,
-                    enabledWhen: field.enabledWhen ?? null,
+                    visibleIf: field.visibleIf ?? null,
+                    enabledIf: field.enabledIf ?? null,
                 })),
             })),
             rules: resource.views.create.rules ?? null,
+            messages: resource.views.create.messages ?? null,
             rulesLink: resource.views.create.rulesLink
                 ? {
                     resolvedPath: resource.views.create.rulesLink.resolvedPath,
@@ -833,6 +924,8 @@ function resolveResourceValidation(resource, modelMap, modelNames, resourceMap,
                 customRenderer: Boolean(field.customRenderer),
             })),
             related: resource.views.read.related.map((panel) => panel.field),
+            messages: resource.views.read.messages ?? null,
+            workflowMessages: resource.workflow ? resource.workflowMessages ?? null : null,
         }), previous?.read, () => validateReadView(resource, modelMap.get(resource.model), Array.from(modelMap.values()), Array.from(resourceMap.values())))
         : undefined;
     return {
@@ -934,6 +1027,7 @@ function validateResourceBase(resource, modelMap) {
             }
             validateWorkflowExpr(transition.allow, resource.workflow.id, errors, (path) => validateWorkflowTransitionIdentifier(path, resource.name, modelFieldNames));
         }
+        pushWorkflowMessageWarnings(resource, Boolean(resource.views.read?.related.length), errors);
     }
     return errors;
 }
@@ -1009,7 +1103,34 @@ function validateListView(resource, model, view, models, resources) {
             });
         }
     }
+    for (const action of view.batchActions) {
+        if (action.name !== 'delete') {
+            errors.push({
+                message: `List batch action "${action.name}" in resource "${resource.name}" is not supported in the current slice; only "delete" is supported`,
+                nodeId: action.id,
+                severity: 'error',
+            });
+            continue;
+        }
+        if (!view.actions.some((entry) => entry.name === 'delete')) {
+            errors.push({
+                message: `List batch action "delete" in resource "${resource.name}" requires list.actions to include delete`,
+                nodeId: action.id,
+                severity: 'error',
+            });
+        }
+    }
+    for (const format of view.exportFormats) {
+        if (format !== 'csv' && format !== 'xlsx') {
+            errors.push({
+                message: `List export "${format}" in resource "${resource.name}" is not supported in the current slice; only "csv" and "xlsx" are supported`,
+                nodeId: view.id,
+                severity: 'error',
+            });
+        }
+    }
     validateViewRulePaths(view.id, view.rules, errors);
+    pushListMessageWarnings(resource, view, errors);
     return errors;
 }
 function validateEditView(resource, model, modelMap, resourceMap, pageMap) {
@@ -1148,6 +1269,7 @@ function validateEditView(resource, model, modelMap, resourceMap, pageMap) {
     }
     validateViewRulePaths(view.id, view.rules, errors);
     validateLinkedFormRules(resource, model, view, errors, 'edit');
+    pushEditMessageWarnings(resource, model, view, errors);
     return errors;
 }
 function validateCreateView(resource, model, modelMap, resourceMap, pageMap) {
@@ -1271,6 +1393,7 @@ function validateCreateView(resource, model, modelMap, resourceMap, pageMap) {
     }
     validateViewRulePaths(view.id, view.rules, errors);
     validateLinkedFormRules(resource, model, view, errors, 'create');
+    pushCreateMessageWarnings(resource, model, view, errors);
     return errors;
 }
 function validateReadView(resource, model, models, resources) {
@@ -1343,6 +1466,7 @@ function validateReadView(resource, model, models, resources) {
             });
         }
     }
+    pushReadMessageWarnings(resource, view, errors);
     return errors;
 }
 function validateToastEffect(effect, context, errors) {
@@ -1354,6 +1478,337 @@ function validateToastEffect(effect, context, errors) {
 function isInverseRelationField(field) {
     return field.fieldType.type === 'relation' && field.fieldType.kind === 'hasMany';
 }
+function hasVersionFieldInFormView(model, view) {
+    if (!model) {
+        return false;
+    }
+    const fieldMap = new Map(model.fields.map((field) => [field.name, field]));
+    return view.fields
+        .map((field) => fieldMap.get(field.field))
+        .some((field) => Boolean(field) && field.decorators.some((decorator) => decorator.name === 'version'));
+}
+function pushMessageFallbackWarning(errors, nodeId, messageKey, fallback) {
+    errors.push({
+        message: `message "${messageKey}" not declared — generated code will use English fallback "${fallback}"`,
+        nodeId,
+        severity: 'warning',
+    });
+}
+function reportMissingMessage(errors, reporter, nodeId, ownerKind, ownerName, surface, key, fallback) {
+    const messageKey = surface === 'workflowMessages'
+        ? `workflowMessages.${key}`
+        : surface === 'page'
+            ? `page.messages.${key}`
+            : `messages.${key}`;
+    if (errors) {
+        pushMessageFallbackWarning(errors, nodeId, messageKey, fallback);
+    }
+    reporter?.({
+        nodeId,
+        ownerKind,
+        ownerName,
+        surface,
+        key,
+        fallback,
+    });
+}
+function pushListMessageWarnings(resource, view, errors, reporter) {
+    const messages = view.messages ?? {};
+    if (!messages.loadFailed) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'loadFailed', 'Failed to load data');
+    }
+    if (resource.views.create && !messages.createLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'createLabel', 'Create');
+    }
+    if (view.actions.some((action) => action.name === 'view') && !messages.viewLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'viewLabel', 'View');
+    }
+    if (view.actions.some((action) => action.name === 'edit') && !messages.editLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'editLabel', 'Edit');
+    }
+    if (view.actions.some((action) => action.name === 'workflow') && !messages.workflowLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'workflowLabel', 'Workflow');
+    }
+    if (view.actions.some((action) => action.name === 'delete') && !messages.deleteLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'deleteLabel', 'Delete');
+    }
+    if (view.batchActions.some((action) => action.name === 'delete') && !messages.deleteSelectedLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'deleteSelectedLabel', 'Delete selected');
+    }
+    if (view.exportFormats.length > 1 && !messages.exportLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'exportLabel', 'Export');
+    }
+    if (view.exportFormats.includes('csv') && !messages.exportCsvLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'exportCsvLabel', 'Export CSV');
+    }
+    if (view.exportFormats.includes('xlsx') && !messages.exportXlsxLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'exportXlsxLabel', 'Export XLSX');
+    }
+    if ((view.actions.some((action) => action.name === 'delete') || view.batchActions.some((action) => action.name === 'delete')) && !messages.deleted) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'deleted', 'Archived/Deleted successfully');
+    }
+    if (view.exportFormats.length > 0 && !messages.exportReady) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'list', 'exportReady', 'Export ready');
+    }
+}
+function pushEditMessageWarnings(resource, model, view, errors, reporter) {
+    const messages = view.messages ?? {};
+    if (!messages.saveFailed) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'saveFailed', 'Failed to save');
+    }
+    if (!messages.permissionDenied) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'permissionDenied', 'You do not have permission to perform this action');
+    }
+    if (!messages.cancelLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'cancelLabel', 'Cancel');
+    }
+    if (!messages.loadingLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'loadingLabel', 'Loading...');
+    }
+    if (!messages.notFound) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'notFound', 'Record not found');
+    }
+    if (!resource.workflow && !messages.saveLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'saveLabel', 'Save');
+    }
+    if (resource.workflow && !messages.workflowLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'workflowLabel', 'Workflow');
+    }
+    if (resource.workflow && !messages.saveAndContinueLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'saveAndContinueLabel', 'Save and continue to {step}');
+    }
+    if (hasVersionFieldInFormView(model, view) && !messages.versionConflict) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'versionConflict', 'This record changed since you loaded it. Reload and try again.');
+    }
+    if (hasVersionFieldInFormView(model, view) && !messages.reloadLatest) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'reloadLatest', 'Reload latest');
+    }
+    if (view.includes.some((include) => include.minItems > 0) && !messages.minItemsRequired) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'minItemsRequired', 'At least {count} {field} item(s) required in the current slice.');
+    }
+    if (view.includes.length > 0 && !messages.existingItemLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'existingItemLabel', 'Existing');
+    }
+    if (view.includes.length > 0 && !messages.newItemLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'edit', 'newItemLabel', 'New');
+    }
+}
+function pushCreateMessageWarnings(resource, model, view, errors, reporter) {
+    const messages = view.messages ?? {};
+    if (!messages.createFailed) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'createFailed', 'Failed to create');
+    }
+    if (!messages.permissionDenied) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'permissionDenied', 'You do not have permission to perform this action');
+    }
+    if (!messages.cancelLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'cancelLabel', 'Cancel');
+    }
+    if (!messages.loadingLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'loadingLabel', 'Loading...');
+    }
+    if (!messages.notFound) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'notFound', 'Record not found');
+    }
+    if (!resource.workflow && !messages.createLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'createLabel', 'Create');
+    }
+    if (resource.workflow && !messages.createAndContinueLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'createAndContinueLabel', 'Create and continue to {step}');
+    }
+    if (hasVersionFieldInFormView(model, view) && !messages.versionConflict) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'versionConflict', 'This record changed since you loaded it. Reload and try again.');
+    }
+    if (view.includes.some((include) => include.minItems > 0) && !messages.minItemsRequired) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'minItemsRequired', 'At least {count} {field} item(s) required in the current slice.');
+    }
+    if (view.includes.length > 0 && !messages.existingItemLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'existingItemLabel', 'Existing');
+    }
+    if (view.includes.length > 0 && !messages.newItemLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'create', 'newItemLabel', 'New');
+    }
+}
+function pushReadMessageWarnings(resource, view, errors, reporter) {
+    const messages = view.messages ?? {};
+    if (!messages.loadFailed) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'loadFailed', 'Failed to load record');
+    }
+    if (!messages.loadingLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'loadingLabel', 'Loading...');
+    }
+    if (!messages.notFound) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'notFound', 'Record not found');
+    }
+    if (!messages.backLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'backLabel', 'Back');
+    }
+    if (resource.views.edit && !messages.editLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'editLabel', 'Edit');
+    }
+    if (resource.workflow && !messages.workflowLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'workflowLabel', 'Workflow');
+    }
+    if (view.related.length > 0 && !messages.relatedTitle) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'relatedTitle', 'Related');
+    }
+    if (view.related.length > 0 && !messages.emptyRelated) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'emptyRelated', 'No related records');
+    }
+    if (view.related.length > 0 && !messages.createRelatedLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'createRelatedLabel', 'Create');
+    }
+    if (view.related.length > 0 && !messages.viewAllRelatedLabel) {
+        reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'viewAllRelatedLabel', 'View all');
+    }
+    if (resource.workflow) {
+        if (!messages.currentState) {
+            reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'currentState', 'Current state');
+        }
+        if (!messages.currentStep) {
+            reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'currentStep', 'Current step');
+        }
+        if (!messages.nextStep) {
+            reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'nextStep', 'Next step');
+        }
+        if (!messages.stepDone) {
+            reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'stepDone', 'done');
+        }
+        if (!messages.stepCurrent) {
+            reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'stepCurrent', 'current');
+        }
+        if (!messages.stepUpcoming) {
+            reportMissingMessage(errors, reporter, view.id, 'resource', resource.name, 'read', 'stepUpcoming', 'upcoming');
+        }
+    }
+}
+function pushWorkflowMessageWarnings(resource, hasRelatedPanels, errors, reporter) {
+    const messages = resource.workflowMessages ?? {};
+    const nodeId = resource.workflow?.id ?? resource.id;
+    if (!messages.preconditionBlocked) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'preconditionBlocked', 'Action blocked by workflow preconditions');
+    }
+    if (!messages.invalidTransition) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'invalidTransition', 'Invalid workflow transition request');
+    }
+    if (!messages.updated) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'updated', 'Workflow updated');
+    }
+    if (!messages.updateFailed) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'updateFailed', 'Failed to update workflow');
+    }
+    if (!messages.title) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'title', 'Workflow');
+    }
+    if (!messages.loadFailed) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'loadFailed', 'Failed to load record');
+    }
+    if (!messages.loadingLabel) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'loadingLabel', 'Loading...');
+    }
+    if (!messages.notFound) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'notFound', 'Record not found');
+    }
+    if (!messages.backLabel) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'backLabel', 'Back');
+    }
+    if (resource.views.edit && !messages.editLabel) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'editLabel', 'Edit');
+    }
+    if (resource.views.read && !messages.viewLabel) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'viewLabel', 'View');
+    }
+    if (hasRelatedPanels && !messages.relatedTitle) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'relatedTitle', 'Related');
+    }
+    if (hasRelatedPanels && !messages.emptyRelated) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'emptyRelated', 'No related records');
+    }
+    if (hasRelatedPanels && !messages.createRelatedLabel) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'createRelatedLabel', 'Create');
+    }
+    if (hasRelatedPanels && !messages.viewAllRelatedLabel) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'viewAllRelatedLabel', 'View all');
+    }
+    if (!messages.currentState) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'currentState', 'Current state');
+    }
+    if (!messages.currentStep) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'currentStep', 'Current step');
+    }
+    if (!messages.nextStep) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'nextStep', 'Next step');
+    }
+    if (!messages.stepDone) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'stepDone', 'done');
+    }
+    if (!messages.stepCurrent) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'stepCurrent', 'current');
+    }
+    if (!messages.stepUpcoming) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'stepUpcoming', 'upcoming');
+    }
+    if (!messages.redoStep) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'redoStep', 'Redo {step}');
+    }
+    if (!messages.completeStep) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'completeStep', 'Complete {step}');
+    }
+    if (!messages.advanceToStep) {
+        reportMissingMessage(errors, reporter, nodeId, 'resource', resource.name, 'workflowMessages', 'advanceToStep', 'Advance to {step}');
+    }
+}
+function pushPageMessageWarnings(page, errors, reporter) {
+    const messages = page.messages ?? {};
+    const hasDataBlocks = page.blocks.some((block) => block.blockType === 'table'
+        || block.blockType === 'timeline'
+        || block.blockType === 'notes'
+        || block.blockType === 'attachments'
+        || block.blockType === 'metric');
+    if (!hasDataBlocks) {
+        return;
+    }
+    if (!messages.loadFailed) {
+        reportMissingMessage(errors, reporter, page.id, 'page', page.name, 'page', 'loadFailed', 'Failed to load data');
+    }
+    if (!messages.loadingLabel) {
+        reportMissingMessage(errors, reporter, page.id, 'page', page.name, 'page', 'loadingLabel', 'Loading...');
+    }
+}
+export function collectMissingMessageTemplateEntries(ir) {
+    const entries = [];
+    const seen = new Set();
+    const reporter = (entry) => {
+        const signature = `${entry.ownerKind}:${entry.ownerName}:${entry.surface}:${entry.key}`;
+        if (seen.has(signature)) {
+            return;
+        }
+        seen.add(signature);
+        entries.push(entry);
+    };
+    const modelMap = new Map(ir.models.map((model) => [model.name, model]));
+    for (const resource of ir.resources) {
+        if (resource.workflow) {
+            pushWorkflowMessageWarnings(resource, Boolean(resource.views.read?.related.length), [], reporter);
+        }
+        if (resource.views.list) {
+            pushListMessageWarnings(resource, resource.views.list, [], reporter);
+        }
+        if (resource.views.edit) {
+            pushEditMessageWarnings(resource, modelMap.get(resource.model), resource.views.edit, [], reporter);
+        }
+        if (resource.views.create) {
+            pushCreateMessageWarnings(resource, modelMap.get(resource.model), resource.views.create, [], reporter);
+        }
+        if (resource.views.read) {
+            pushReadMessageWarnings(resource, resource.views.read, [], reporter);
+        }
+    }
+    for (const page of ir.pages) {
+        pushPageMessageWarnings(page, [], reporter);
+    }
+    return entries;
+}
 function formatRelationProjectionError(subject, resource, analysis) {
     switch (analysis.reason) {
         case 'unsupportedPathShape':
@@ -1574,18 +2029,25 @@ function validatePage(page, resources, models, readModels) {
             || analysis.kind === 'resourceList'
             || analysis.kind === 'readModelList'
             || analysis.kind === 'readModelCount'
+            || analysis.kind === 'readModelValue'
             || analysis.kind === 'recordRelationList'
             || analysis.kind === 'recordRelationCount') {
             continue;
         }
         const blockLabel = block.title || block.id;
-        const blockKindLabel = block.blockType === 'metric' ? 'Metric block' : 'Table block';
+        const blockKindLabel = pageBlockKindLabel(block);
         switch (analysis.reason) {
             case 'missingData':
                 errors.push({
                     message: block.blockType === 'metric'
-                        ? `Metric block "${blockLabel}" in page "${page.name}" must set data: readModel.<name>.count or data: <resource>.<hasManyField>.count`
-                        : `Table block "${blockLabel}" in page "${page.name}" must set data: <resource>.list, data: readModel.<name>.list, or data: <resource>.<hasManyField>`,
+                        ? `Metric block "${blockLabel}" in page "${page.name}" must set data: readModel.<name>.count, data: readModel.<name>.<field>, or data: <resource>.<hasManyField>.count`
+                        : block.blockType === 'timeline'
+                            ? `Timeline block "${blockLabel}" in page "${page.name}" must set data: readModel.<name>.list or data: <resource>.<hasManyField>`
+                            : block.blockType === 'notes'
+                                ? `Notes block "${blockLabel}" in page "${page.name}" must set data: readModel.<name>.list or data: <resource>.<hasManyField>`
+                                : block.blockType === 'attachments'
+                                    ? `Attachments block "${blockLabel}" in page "${page.name}" must set data: readModel.<name>.list or data: <resource>.<hasManyField>`
+                                    : `Table block "${blockLabel}" in page "${page.name}" must set data: <resource>.list, data: readModel.<name>.list, or data: <resource>.<hasManyField>`,
                     nodeId: block.id,
                     severity: 'error',
                 });
@@ -1593,8 +2055,14 @@ function validatePage(page, resources, models, readModels) {
             case 'unsupportedDataRef':
                 errors.push({
                     message: block.blockType === 'metric'
-                        ? `Metric block "${blockLabel}" in page "${page.name}" must use data: readModel.<name>.count or data: <resource>.<hasManyField>.count; got "${analysis.data}"`
-                        : `Table block "${blockLabel}" in page "${page.name}" must use data: <resource>.list, data: readModel.<name>.list, or data: <resource>.<hasManyField>; got "${analysis.data}"`,
+                        ? `Metric block "${blockLabel}" in page "${page.name}" must use data: readModel.<name>.count, data: readModel.<name>.<field>, or data: <resource>.<hasManyField>.count; got "${analysis.data}"`
+                        : block.blockType === 'timeline'
+                            ? `Timeline block "${blockLabel}" in page "${page.name}" must use data: readModel.<name>.list or data: <resource>.<hasManyField>; got "${analysis.data}"`
+                            : block.blockType === 'notes'
+                                ? `Notes block "${blockLabel}" in page "${page.name}" must use data: readModel.<name>.list or data: <resource>.<hasManyField>; got "${analysis.data}"`
+                                : block.blockType === 'attachments'
+                                    ? `Attachments block "${blockLabel}" in page "${page.name}" must use data: readModel.<name>.list or data: <resource>.<hasManyField>; got "${analysis.data}"`
+                                    : `Table block "${blockLabel}" in page "${page.name}" must use data: <resource>.list, data: readModel.<name>.list, or data: <resource>.<hasManyField>; got "${analysis.data}"`,
                     nodeId: block.id,
                     severity: 'error',
                 });
@@ -1613,6 +2081,13 @@ function validatePage(page, resources, models, readModels) {
                     severity: 'error',
                 });
                 break;
+            case 'readModelResultFieldMissing':
+                errors.push({
+                    message: `${blockKindLabel} "${blockLabel}" in page "${page.name}" references missing read-model result field "${analysis.readModelFieldName}" on "${analysis.readModelName}"`,
+                    nodeId: block.id,
+                    severity: 'error',
+                });
+                break;
             case 'resourceMissing':
                 errors.push({
                     message: `${blockKindLabel} "${blockLabel}" in page "${page.name}" references unknown resource "${analysis.resourceName}"`,
@@ -1622,7 +2097,7 @@ function validatePage(page, resources, models, readModels) {
                 break;
             case 'resourceListMissing':
                 errors.push({
-                    message: `Table block "${blockLabel}" in page "${page.name}" requires resource "${analysis.resourceName}" to define list:`,
+                    message: `${blockKindLabel} "${blockLabel}" in page "${page.name}" requires resource "${analysis.resourceName}" to define list:`,
                     nodeId: block.id,
                     severity: 'error',
                 });
@@ -1664,7 +2139,7 @@ function validatePage(page, resources, models, readModels) {
                 break;
             case 'targetResourceListMissing':
                 errors.push({
-                    message: `Table block "${blockLabel}" in page "${page.name}" requires related resource "${analysis.targetResource?.name ?? analysis.targetModel?.name}" to define list:`,
+                    message: `${blockKindLabel} "${blockLabel}" in page "${page.name}" requires related resource "${analysis.targetResource?.name ?? analysis.targetModel?.name}" to define list:`,
                     nodeId: block.id,
                     severity: 'error',
                 });
@@ -1676,6 +2151,58 @@ function validatePage(page, resources, models, readModels) {
     for (const block of page.blocks) {
         const analysis = analyzePageBlockData(block, resources, models, readModels);
         const blockLabel = block.title || block.id;
+        if (block.blockType === 'timeline') {
+            if (analysis.kind !== 'readModelList' && analysis.kind !== 'recordRelationList') {
+                errors.push({
+                    message: `Timeline block "${blockLabel}" in page "${page.name}" must use data: readModel.<name>.list or data: <resource>.<hasManyField> in the current slice`,
+                    nodeId: block.id,
+                    severity: 'error',
+                });
+            }
+            else if (analysis.kind === 'recordRelationList') {
+                errors.push(...validateTimelineBlock(page, block, analysis.targetModel, `related model "${analysis.targetModel.name}"`));
+            }
+            else {
+                errors.push(...validateTimelineBlock(page, block, analysis.readModel, `read-model "${analysis.readModel.name}" result`));
+            }
+        }
+        if (block.blockType === 'notes') {
+            if (analysis.kind !== 'readModelList' && analysis.kind !== 'recordRelationList') {
+                errors.push({
+                    message: `Notes block "${blockLabel}" in page "${page.name}" must use data: readModel.<name>.list or data: <resource>.<hasManyField> in the current slice`,
+                    nodeId: block.id,
+                    severity: 'error',
+                });
+            }
+            else if (analysis.kind === 'recordRelationList') {
+                errors.push(...validateNotesBlock(page, block, analysis.targetModel, `related model "${analysis.targetModel.name}"`));
+            }
+            else {
+                errors.push(...validateNotesBlock(page, block, analysis.readModel, `read-model "${analysis.readModel.name}" result`));
+            }
+        }
+        if (block.blockType === 'attachments') {
+            if (analysis.kind !== 'readModelList' && analysis.kind !== 'recordRelationList') {
+                errors.push({
+                    message: `Attachments block "${blockLabel}" in page "${page.name}" must use data: readModel.<name>.list or data: <resource>.<hasManyField> in the current slice`,
+                    nodeId: block.id,
+                    severity: 'error',
+                });
+            }
+            else if (analysis.kind === 'recordRelationList') {
+                errors.push(...validateAttachmentsBlock(page, block, analysis.targetModel, `related model "${analysis.targetModel.name}"`));
+            }
+            else {
+                errors.push(...validateAttachmentsBlock(page, block, analysis.readModel, `read-model "${analysis.readModel.name}" result`));
+            }
+        }
+        if (block.blockType === 'table' && analysis.kind === 'readModelList' && analysis.listView.columns.length === 0) {
+            errors.push({
+                message: `Table block "${blockLabel}" in page "${page.name}" requires read-model "${analysis.readModel.name}" list to define at least one column`,
+                nodeId: block.id,
+                severity: 'error',
+            });
+        }
         if (block.queryState) {
             if (block.queryState.trim() === '') {
                 errors.push({
@@ -1684,9 +2211,9 @@ function validatePage(page, resources, models, readModels) {
                     severity: 'error',
                 });
             }
-            else if (analysis.kind !== 'readModelList' && analysis.kind !== 'readModelCount') {
+            else if (analysis.kind !== 'readModelList' && analysis.kind !== 'readModelCount' && analysis.kind !== 'readModelValue') {
                 errors.push({
-                    message: `Page block "${blockLabel}" in page "${page.name}" may only use queryState with data: readModel.<name>.list or data: readModel.<name>.count`,
+                    message: `Page block "${blockLabel}" in page "${page.name}" may only use queryState with data: readModel.<name>.list, data: readModel.<name>.count, or data: readModel.<name>.<field>`,
                     nodeId: block.id,
                     severity: 'error',
                 });
@@ -1705,6 +2232,27 @@ function validatePage(page, resources, models, readModels) {
                     severity: 'error',
                 });
             }
+            else if (block.blockType === 'timeline') {
+                errors.push({
+                    message: `Timeline block "${blockLabel}" in page "${page.name}" may not use selectionState`,
+                    nodeId: block.id,
+                    severity: 'error',
+                });
+            }
+            else if (block.blockType === 'notes') {
+                errors.push({
+                    message: `Notes block "${blockLabel}" in page "${page.name}" may not use selectionState`,
+                    nodeId: block.id,
+                    severity: 'error',
+                });
+            }
+            else if (block.blockType === 'attachments') {
+                errors.push({
+                    message: `Attachments block "${blockLabel}" in page "${page.name}" may not use selectionState`,
+                    nodeId: block.id,
+                    severity: 'error',
+                });
+            }
             else if (analysis.kind !== 'readModelList' || block.blockType !== 'table') {
                 errors.push({
                     message: `Page block "${blockLabel}" in page "${page.name}" may only use selectionState with data: readModel.<name>.list table consumers in the current slice`,
@@ -1744,7 +2292,7 @@ function validatePage(page, resources, models, readModels) {
                     severity: 'error',
                 });
             }
-            else if (inputField.fieldType.type !== 'scalar' || (inputField.fieldType.name !== 'string' && inputField.fieldType.name !== 'datetime')) {
+            else if (inputField.fieldType.type !== 'scalar' || !['string', 'date', 'datetime'].includes(inputField.fieldType.name)) {
                 errors.push({
                     message: `Page block "${blockLabel}" in page "${page.name}" dateNavigation field "${dateNavigation.field}" must be a string/date-like read-model input in the current slice`,
                     nodeId: block.id,
@@ -1773,6 +2321,184 @@ function validatePage(page, resources, models, readModels) {
         errors.push(...validatePageBlockRowActions(page, block, resources, models, readModels));
     }
     errors.push(...validatePageActions(page, resources, models, queryStateGroups, selectionStateGroups));
+    pushPageMessageWarnings(page, errors);
+    return errors;
+}
+function pageBlockKindLabel(block) {
+    if (block.blockType === 'metric') {
+        return 'Metric block';
+    }
+    if (block.blockType === 'timeline') {
+        return 'Timeline block';
+    }
+    if (block.blockType === 'notes') {
+        return 'Notes block';
+    }
+    if (block.blockType === 'attachments') {
+        return 'Attachments block';
+    }
+    return 'Table block';
+}
+function validateFieldContract(fields, fieldName, typeName) {
+    const field = fields.find((candidate) => candidate.name === fieldName);
+    return Boolean(field && field.fieldType.type === 'scalar' && field.fieldType.name === typeName);
+}
+function validateTimelineBlock(page, block, source, sourceLabel) {
+    const errors = [];
+    const blockLabel = block.title || block.id;
+    const fields = 'result' in source ? source.result : source.fields;
+    if (!validateFieldContract(fields, 'action', 'string')) {
+        errors.push({
+            message: `Timeline block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.action: string`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    if (!validateFieldContract(fields, 'performedAt', 'datetime')) {
+        errors.push({
+            message: `Timeline block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.performedAt: datetime`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    for (const fieldName of ['performedBy', 'message', 'beforeState', 'afterState']) {
+        const field = fields.find((candidate) => candidate.name === fieldName);
+        if (!field) {
+            continue;
+        }
+        if (field.fieldType.type !== 'scalar' || field.fieldType.name !== 'string') {
+            errors.push({
+                message: `Timeline block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.${fieldName}: string when present`,
+                nodeId: block.id,
+                severity: 'error',
+            });
+        }
+    }
+    if (block.rowActions.length > 0) {
+        errors.push({
+            message: `Timeline block "${blockLabel}" in page "${page.name}" may not use rowActions`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    if (block.selectionState) {
+        errors.push({
+            message: `Timeline block "${blockLabel}" in page "${page.name}" may not use selectionState`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    return errors;
+}
+function validateNotesBlock(page, block, source, sourceLabel) {
+    const errors = [];
+    const blockLabel = block.title || block.id;
+    const fields = 'result' in source ? source.result : source.fields;
+    if (!validateFieldContract(fields, 'body', 'string')) {
+        errors.push({
+            message: `Notes block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.body: string`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    if (!validateFieldContract(fields, 'notedAt', 'datetime')) {
+        errors.push({
+            message: `Notes block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.notedAt: datetime`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    for (const fieldName of ['notedBy', 'title']) {
+        const field = fields.find((candidate) => candidate.name === fieldName);
+        if (!field) {
+            continue;
+        }
+        if (field.fieldType.type !== 'scalar' || field.fieldType.name !== 'string') {
+            errors.push({
+                message: `Notes block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.${fieldName}: string when present`,
+                nodeId: block.id,
+                severity: 'error',
+            });
+        }
+    }
+    const visibilityField = fields.find((candidate) => candidate.name === 'visibility');
+    if (visibilityField
+        && ((visibilityField.fieldType.type !== 'scalar' || visibilityField.fieldType.name !== 'string')
+            && visibilityField.fieldType.type !== 'enum')) {
+        errors.push({
+            message: `Notes block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.visibility: string or enum(...) when present`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    if (block.rowActions.length > 0) {
+        errors.push({
+            message: `Notes block "${blockLabel}" in page "${page.name}" may not use rowActions`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    if (block.selectionState) {
+        errors.push({
+            message: `Notes block "${blockLabel}" in page "${page.name}" may not use selectionState`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    return errors;
+}
+function validateAttachmentsBlock(page, block, source, sourceLabel) {
+    const errors = [];
+    const blockLabel = block.title || block.id;
+    const fields = 'result' in source ? source.result : source.fields;
+    if (!validateFieldContract(fields, 'fileName', 'string')) {
+        errors.push({
+            message: `Attachments block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.fileName: string`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    if (!validateFieldContract(fields, 'fileUrl', 'string')) {
+        errors.push({
+            message: `Attachments block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.fileUrl: string`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    if (!validateFieldContract(fields, 'attachedAt', 'datetime')) {
+        errors.push({
+            message: `Attachments block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.attachedAt: datetime`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    for (const fieldName of ['attachedBy', 'mediaType', 'sizeLabel', 'title']) {
+        const field = fields.find((candidate) => candidate.name === fieldName);
+        if (!field) {
+            continue;
+        }
+        if (field.fieldType.type !== 'scalar' || field.fieldType.name !== 'string') {
+            errors.push({
+                message: `Attachments block "${blockLabel}" in page "${page.name}" requires ${sourceLabel}.${fieldName}: string when present`,
+                nodeId: block.id,
+                severity: 'error',
+            });
+        }
+    }
+    if (block.rowActions.length > 0) {
+        errors.push({
+            message: `Attachments block "${blockLabel}" in page "${page.name}" may not use rowActions`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
+    if (block.selectionState) {
+        errors.push({
+            message: `Attachments block "${blockLabel}" in page "${page.name}" may not use selectionState`,
+            nodeId: block.id,
+            severity: 'error',
+        });
+    }
     return errors;
 }
 function serializeReadModelInputSignature(readModel) {
@@ -1789,7 +2515,13 @@ function validatePageBlockRowActions(page, block, resources, models, readModels)
     }
     if (block.blockType !== 'table') {
         errors.push({
-            message: `Page block "${block.title || block.id}" in page "${page.name}" may only use rowActions on type: table`,
+            message: block.blockType === 'timeline'
+                ? `Timeline block "${block.title || block.id}" in page "${page.name}" may not use rowActions`
+                : block.blockType === 'notes'
+                    ? `Notes block "${block.title || block.id}" in page "${page.name}" may not use rowActions`
+                    : block.blockType === 'attachments'
+                        ? `Attachments block "${block.title || block.id}" in page "${page.name}" may not use rowActions`
+                        : `Page block "${block.title || block.id}" in page "${page.name}" may only use rowActions on type: table`,
             nodeId: block.id,
             severity: 'error',
         });
@@ -2043,30 +2775,75 @@ function validateRuleValuePath(rule, key, nodeId, errors) {
     }
 }
 function validateFormFieldRulePaths(field, errors) {
-    validateRuleValuePath(field.visibleWhen, 'field.visibleIf', field.id, errors);
-    validateRuleValuePath(field.enabledWhen, 'field.enabledIf', field.id, errors);
+    validateRuleValuePath(field.visibleIf, 'field.visibleIf', field.id, errors);
+    validateRuleValuePath(field.enabledIf, 'field.enabledIf', field.id, errors);
 }
 function validateFormFieldRules(field, errors, validateIdentifier) {
-    if (field.visibleWhen?.source === 'builtin') {
-        validateWorkflowExpr(field.visibleWhen.expr, field.id, errors, validateIdentifier);
+    if (field.visibleIf?.source === 'builtin') {
+        validateWorkflowExpr(field.visibleIf.expr, field.id, errors, validateIdentifier);
     }
-    if (field.enabledWhen?.source === 'builtin') {
-        validateWorkflowExpr(field.enabledWhen.expr, field.id, errors, validateIdentifier);
+    if (field.enabledIf?.source === 'builtin') {
+        validateWorkflowExpr(field.enabledIf.expr, field.id, errors, validateIdentifier);
     }
 }
 function validateWorkflowExpr(expr, nodeId, errors, validateIdentifier) {
-    visitExpr(expr, (node) => {
+    const visitScoped = (node, bound = new Set()) => {
         if (node.type === 'identifier') {
-            const error = validateIdentifier(node.path);
-            if (error) {
-                errors.push({
-                    message: error,
-                    nodeId,
-                    severity: 'error',
-                });
+            if (!(node.path.length > 0 && bound.has(node.path[0]))) {
+                const error = validateIdentifier(node.path);
+                if (error) {
+                    errors.push({
+                        message: error,
+                        nodeId,
+                        severity: 'error',
+                    });
+                }
             }
+            return;
         }
-    });
+        if (node.type === 'binary') {
+            visitScoped(node.left, bound);
+            visitScoped(node.right, bound);
+            return;
+        }
+        if (node.type === 'unary') {
+            visitScoped(node.operand, bound);
+            return;
+        }
+        if (node.type === 'call') {
+            for (const arg of node.args) {
+                visitScoped(arg, bound);
+            }
+            return;
+        }
+        if (node.type === 'quantifier') {
+            visitScoped(node.collection, bound);
+            const inner = new Set(bound);
+            inner.add(node.binding);
+            visitScoped(node.predicate, inner);
+            return;
+        }
+        if (node.type === 'member') {
+            visitScoped(node.object, bound);
+            return;
+        }
+        if (node.type === 'in') {
+            visitScoped(node.value, bound);
+            for (const item of node.list) {
+                visitScoped(item, bound);
+            }
+            return;
+        }
+        if (node.type === 'nullCheck') {
+            visitScoped(node.value, bound);
+            return;
+        }
+        if (node.type === 'like') {
+            visitScoped(node.value, bound);
+            visitScoped(node.pattern, bound);
+        }
+    };
+    visitScoped(expr);
 }
 function validateWorkflowTransitionIdentifier(path, resourceName, modelFieldNames) {
     if (path.length === 0) {
@@ -2130,7 +2907,7 @@ function validateReadModelRulesEligibilityIdentifier(path, readModelName, inputF
     }
     return `Read-model "${readModelName}" rules eligibility uses unsupported identifier root "${root}"; use currentUser, input, or bare enum-like literals`;
 }
-function validateLinkedFormRulesIdentifier(path, resourceName, mode, modelFieldNames) {
+function validateLinkedFormRulesIdentifier(path, resourceName, mode, modelFieldMap) {
     if (path.length === 0) {
         return undefined;
     }
@@ -2138,9 +2915,6 @@ function validateLinkedFormRulesIdentifier(path, resourceName, mode, modelFieldN
     if (path.length === 1 && /^[A-Z][A-Z0-9_]*$/.test(root)) {
         return undefined;
     }
-    if (rest.length > 0) {
-        return `Resource "${resourceName}" ${mode}.rules support only one-level property access; got "${path.join('.')}"`;
-    }
     if (root === 'currentUser') {
         if (!property) {
             return undefined;
@@ -2154,16 +2928,26 @@ function validateLinkedFormRulesIdentifier(path, resourceName, mode, modelFieldN
         if (!property) {
             return undefined;
         }
-        if (!modelFieldNames.has(property)) {
+        const field = modelFieldMap.get(property);
+        if (!field) {
             return `Resource "${resourceName}" ${mode}.rules reference unknown formData field "${property}"`;
         }
-        return undefined;
+        if (rest.length === 0) {
+            return undefined;
+        }
+        if (rest.length === 1 && field.fieldType.type === 'relation' && field.fieldType.kind === 'hasMany') {
+            return undefined;
+        }
+        return `Resource "${resourceName}" ${mode}.rules support only one-level property access except direct hasMany(...) projection; got "${path.join('.')}"`;
+    }
+    if (rest.length > 0) {
+        return `Resource "${resourceName}" ${mode}.rules support only one-level property access; got "${path.join('.')}"`;
     }
     if (root === 'record' && mode === 'edit') {
         if (!property) {
             return undefined;
         }
-        if (property !== 'id' && !modelFieldNames.has(property)) {
+        if (property !== 'id' && !modelFieldMap.has(property)) {
             return `Resource "${resourceName}" edit.rules reference unknown record field "${property}"`;
         }
         return undefined;
@@ -2369,6 +3153,11 @@ function visitExpr(expr, visit) {
         }
         return;
     }
+    if (expr.type === 'quantifier') {
+        visitExpr(expr.collection, visit);
+        visitExpr(expr.predicate, visit);
+        return;
+    }
     if (expr.type === 'member') {
         visitExpr(expr.object, visit);
         return;
@@ -2454,6 +3243,70 @@ function validateRouteTarget(target, nodeId, resourceMap, pageMap, errors) {
         }
     }
 }
+function validateStaticAppRouteTarget(target, nodeId, resourceMap, pageMap, errors, routeName) {
+    const parts = target.split('.');
+    if (parts[0] === 'page' && parts.length === 2) {
+        const page = pageMap.get(parts[1]);
+        if (!page) {
+            errors.push({
+                message: `app.routes.${routeName} references unknown page "${parts[1]}"`,
+                nodeId,
+                severity: 'error',
+            });
+            return;
+        }
+        if (page.path && page.path.split('/').some((segment) => segment.startsWith(':'))) {
+            errors.push({
+                message: `app.routes.${routeName} references page "${parts[1]}" with record-scoped path "${page.path}"; only static page routes are supported`,
+                nodeId,
+                severity: 'error',
+            });
+        }
+        return;
+    }
+    if (parts[0] === 'resource' && parts.length === 3) {
+        const resource = resourceMap.get(parts[1]);
+        if (!resource) {
+            errors.push({
+                message: `app.routes.${routeName} references unknown resource "${parts[1]}"`,
+                nodeId,
+                severity: 'error',
+            });
+            return;
+        }
+        if (parts[2] === 'list') {
+            if (!resource.views.list) {
+                errors.push({
+                    message: `app.routes.${routeName} requires resource "${resource.name}" to define list:`,
+                    nodeId,
+                    severity: 'error',
+                });
+            }
+            return;
+        }
+        if (parts[2] === 'create') {
+            if (!resource.views.create) {
+                errors.push({
+                    message: `app.routes.${routeName} requires resource "${resource.name}" to define create:`,
+                    nodeId,
+                    severity: 'error',
+                });
+            }
+            return;
+        }
+        errors.push({
+            message: `app.routes.${routeName} only supports static resource views; use resource.<name>.list or resource.<name>.create`,
+            nodeId,
+            severity: 'error',
+        });
+        return;
+    }
+    errors.push({
+        message: `app.routes.${routeName} must target page.<name> or resource.<name>.list/create`,
+        nodeId,
+        severity: 'error',
+    });
+}
 function validateNavTarget(target, nodeId, resourceMap, pageMap, errors) {
     // Navigation target formats: "resource.users.list", "page.dashboard"
     const parts = target.split('.');