openxiangda-devkit-core 2.0.0-alpha.52 → 2.0.0-alpha.56

package/dist/compiler/config.js

@@ -1,9 +1,22 @@
-import { SCHEMA_VERSIONS, DATA_FIELD_TYPES, nativePlatformCapabilityCatalog, validateDataResource, } from 'openxiangda-contracts';
+import { SCHEMA_VERSIONS, DATA_FIELD_TYPES, PLATFORM_EVENT_TYPES_V2, nativePlatformCapabilityCatalog, validateDataResource, } from 'openxiangda-contracts';
+import { Ajv2020 } from 'ajv/dist/2020.js';
 import { CronExpressionParser } from 'cron-parser';
-import { resolveDataFieldSurfaceWidget } from './field-surface.js';
+import { fieldNullable, isGeneratedField } from './field-codec.js';
+import { supportsFilter, supportsSearch, supportsSort, } from './field-query-plan.js';
+import { physicalPlanForField } from './field-physical-plan.js';
+import { SEMANTIC_FIELD_PATH_PATTERN, semanticFieldPathRoot, validateAuthzSemanticBindings, } from './field-policy-path.js';
+import { compatibleWidgets, isCompatibleFieldWidget, resolveDataFieldSurfaceWidget, } from './field-surface.js';
 // The compiler owns the application source contract. Devkit and every adapter
 // re-export this module instead of maintaining separate configuration models.
 import { validateWorkflowBinding, validateWorkflowDefinition, } from '../internal/workflow.js';
+const DATE_TRIGGER_RESERVED_DATA_FIELDS = new Set([
+    'triggerCode',
+    'resourceCode',
+    'recordId',
+    'recordRevision',
+    'field',
+    'dueAt',
+]);
 const APP_DATA_FIELD_TYPES = new Set(DATA_FIELD_TYPES);
 export const openXiangdaAppConfigSchema = {
     $id: 'openxiangda.app-config/v3',
@@ -150,6 +163,11 @@ export const openXiangdaAppConfigSchema = {
             additionalProperties: false,
             required: ['subscriptions'],
             properties: {
+                schemas: {
+                    type: 'array',
+                    maxItems: 100,
+                    items: { type: 'object' },
+                },
                 subscriptions: {
                     type: 'array',
                     maxItems: 100,
@@ -160,6 +178,11 @@ export const openXiangdaAppConfigSchema = {
                     maxItems: 100,
                     items: { type: 'object' },
                 },
+                dateTriggers: {
+                    type: 'array',
+                    maxItems: 100,
+                    items: { type: 'object' },
+                },
             },
         },
         workflows: {
@@ -235,6 +258,7 @@ export function backendRuntimeRequired(config) {
                 backend.secrets?.length ||
                 config.events?.subscriptions?.length ||
                 config.events?.timers?.length ||
+                config.events?.dateTriggers?.length ||
                 config.workflows?.activations?.length ||
                 config.workflows?.providers?.length)));
 }
@@ -246,6 +270,109 @@ function object(value) {
 function string(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
+function eventSchemaDeclaresPath(schema, path) {
+    let current = schema;
+    for (const segment of path.split('.')) {
+        if (current.type === 'array')
+            current = object(current.items);
+        const properties = object(current.properties);
+        if (!Object.prototype.hasOwnProperty.call(properties, segment)) {
+            return false;
+        }
+        current = object(properties[segment]);
+    }
+    return true;
+}
+function eventDataMatchesSchema(schema, data) {
+    if (!schema)
+        return false;
+    try {
+        const validator = new Ajv2020({
+            allErrors: true,
+            strict: false,
+            validateFormats: false,
+        }).compile(schema);
+        return Boolean(validator(data));
+    }
+    catch {
+        return false;
+    }
+}
+function validDateTriggerOffset(value) {
+    const match = /^([+-])?P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/.exec(string(value));
+    if (!match || !match.slice(2).some(part => part !== undefined))
+        return false;
+    const milliseconds = Number(match[2] || 0) * 24 * 60 * 60 * 1000 +
+        Number(match[3] || 0) * 60 * 60 * 1000 +
+        Number(match[4] || 0) * 60 * 1000 +
+        Number(match[5] || 0) * 1000;
+    return (Number.isFinite(milliseconds) &&
+        milliseconds <= 10 * 365 * 24 * 60 * 60 * 1000);
+}
+const EVENT_TYPE_PATTERN = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9_-]*)+\.v[1-9][0-9]*$/;
+const EVENT_DATA_SCHEMA_VERSION_PATTERN = /^[1-9][0-9]*\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)$/;
+const EVENT_FIELD_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+function eventPredicateValid(value) {
+    const predicate = object(value);
+    const keys = Object.keys(predicate);
+    if (keys.length !== 1 ||
+        !['eq', 'ne', 'in', 'notIn', 'exists'].includes(keys[0] || '')) {
+        return false;
+    }
+    const operand = predicate[keys[0]];
+    if (keys[0] === 'exists' && typeof operand !== 'boolean')
+        return false;
+    if ((keys[0] === 'in' || keys[0] === 'notIn') &&
+        (!Array.isArray(operand) || operand.length < 1 || operand.length > 20))
+        return false;
+    try {
+        const serialized = JSON.stringify(predicate);
+        return (typeof serialized === 'string' &&
+            Buffer.byteLength(serialized, 'utf8') <= 4096);
+    }
+    catch {
+        return false;
+    }
+}
+function validateEventChangeFilter(value, path, allowedFields, diagnostics) {
+    const change = object(value);
+    const field = string(change.field);
+    const keys = Object.keys(change);
+    if (!EVENT_FIELD_PATTERN.test(field) ||
+        !allowedFields.has(field) ||
+        keys.some(key => !['field', 'before', 'after'].includes(key)) ||
+        (!('before' in change) && !('after' in change)) ||
+        ('before' in change && !eventPredicateValid(change.before)) ||
+        ('after' in change && !eventPredicateValid(change.after))) {
+        diagnostics.push(diagnostic('APP_CONFIG_EVENT_CHANGE_FILTER_INVALID', '字段变化条件必须引用已声明字段，并且 before/after 各只使用一个受支持操作符', path));
+    }
+}
+function validateEventFilterCondition(value, path, allowedFields, diagnostics, state, depth = 1) {
+    const condition = object(value);
+    const keys = Object.keys(condition);
+    if (depth > 3 || keys.length !== 1) {
+        diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_COMPLEXITY_EXCEEDED', '事件过滤条件最多嵌套 3 层，且每层只能声明 change/all/any/not 之一', path));
+        return;
+    }
+    const key = keys[0];
+    if (key === 'change') {
+        state.atoms += 1;
+        validateEventChangeFilter(condition.change, `${path}.change`, allowedFields, diagnostics);
+    }
+    else if (key === 'all' || key === 'any') {
+        const items = Array.isArray(condition[key]) ? condition[key] : [];
+        if (items.length < 1 || items.length > 16) {
+            diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_GROUP_INVALID', '事件过滤 all/any 必须包含 1 到 16 个条件', `${path}.${key}`));
+        }
+        items.forEach((item, index) => validateEventFilterCondition(item, `${path}.${key}[${index}]`, allowedFields, diagnostics, state, depth + 1));
+    }
+    else if (key === 'not') {
+        validateEventFilterCondition(condition.not, `${path}.not`, allowedFields, diagnostics, state, depth + 1);
+    }
+    else {
+        diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_OPERATOR_INVALID', '事件过滤条件只支持 change/all/any/not', path));
+    }
+}
 export function validateAppConfig(value) {
     const diagnostics = [];
     const config = object(value);
@@ -318,6 +445,8 @@ export function validateAppConfig(value) {
             Array.isArray(eventConfig.subscriptions) &&
                 eventConfig.subscriptions.length > 0 ||
             Array.isArray(eventConfig.timers) && eventConfig.timers.length > 0 ||
+            Array.isArray(eventConfig.dateTriggers) &&
+                eventConfig.dateTriggers.length > 0 ||
             Array.isArray(workflowConfig.activations) &&
                 workflowConfig.activations.length > 0 ||
             Array.isArray(workflowConfig.providers) && workflowConfig.providers.length > 0)) {
@@ -379,22 +508,54 @@ export function validateAppConfig(value) {
             const fields = object(resourceRecord.schema).fields;
             (Array.isArray(fields) ? fields : []).forEach((rawField, fieldIndex) => {
                 const field = object(rawField);
-                const reference = object(field.reference);
-                if (string(reference.kind) !== 'resource')
+                const source = object(field.source);
+                if (string(source.kind) !== 'resource')
                     return;
-                const targetCode = string(reference.resourceCode);
+                const targetCode = string(source.resourceCode);
                 const target = resources.find(candidate => string(object(candidate).code) === targetCode);
-                const referencePath = `data.resources[${index}].schema.fields[${fieldIndex}].reference`;
+                const sourcePath = `data.resources[${index}].schema.fields[${fieldIndex}].source`;
                 if (!target) {
-                    diagnostics.push(diagnostic('APP_CONFIG_DATA_RESOURCE_REFERENCE_TARGET_NOT_FOUND', `资源引用目标 ${targetCode} 必须在同一应用中声明`, `${referencePath}.resourceCode`));
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_RESOURCE_SOURCE_TARGET_NOT_FOUND', `动态选项来源 ${targetCode} 必须在同一应用中声明`, `${sourcePath}.resourceCode`));
                     return;
                 }
                 const targetFields = object(object(target).schema).fields;
-                const labelField = string(reference.labelField);
+                const targetFieldList = Array.isArray(targetFields) ? targetFields : [];
+                const labelField = string(source.labelField);
                 const label = (Array.isArray(targetFields) ? targetFields : []).find(candidate => string(object(candidate).code) === labelField);
-                if (!label || !['string', 'text'].includes(string(object(label).type))) {
-                    diagnostics.push(diagnostic('APP_CONFIG_DATA_RESOURCE_REFERENCE_LABEL_INVALID', `资源引用标签字段 ${labelField} 必须是 string 或 text`, `${referencePath}.labelField`));
+                if (!label ||
+                    !['text.short', 'text.long', 'serial-number'].includes(string(object(label).type))) {
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_RESOURCE_SOURCE_LABEL_INVALID', `动态选项标签字段 ${labelField} 必须是文本或流水号`, `${sourcePath}.labelField`));
                 }
+                for (const key of [
+                    'searchFields',
+                    'descriptionFields',
+                    'snapshotFields',
+                ]) {
+                    const values = Array.isArray(source[key]) ? source[key] : [];
+                    values.forEach((value, valueIndex) => {
+                        const targetField = targetFieldList.find(candidate => string(object(candidate).code) === string(value));
+                        if (!targetField) {
+                            diagnostics.push(diagnostic('APP_CONFIG_DATA_RESOURCE_SOURCE_FIELD_NOT_FOUND', `动态来源字段 ${String(value)} 未在 ${targetCode} 声明`, `${sourcePath}.${key}[${valueIndex}]`));
+                        }
+                        else if (key === 'searchFields' &&
+                            !supportsSearch(string(object(targetField).type))) {
+                            diagnostics.push(diagnostic('APP_CONFIG_DATA_RESOURCE_SOURCE_SEARCH_UNSUPPORTED', `动态来源字段 ${String(value)} 不支持搜索`, `${sourcePath}.${key}[${valueIndex}]`));
+                        }
+                    });
+                }
+                const sourceFilters = Array.isArray(source.filters) ? source.filters : [];
+                sourceFilters.forEach((rawFilter, filterIndex) => {
+                    const filter = object(rawFilter);
+                    const targetFieldCode = string(filter.field);
+                    if (!targetFieldList.some(candidate => string(object(candidate).code) === targetFieldCode)) {
+                        diagnostics.push(diagnostic('APP_CONFIG_DATA_RESOURCE_SOURCE_FILTER_FIELD_NOT_FOUND', `动态来源筛选字段 ${targetFieldCode} 未在 ${targetCode} 声明`, `${sourcePath}.filters[${filterIndex}].field`));
+                    }
+                    const bindingField = string(object(filter.binding).field);
+                    if (bindingField &&
+                        !(Array.isArray(fields) ? fields : []).some(candidate => string(object(candidate).code) === bindingField)) {
+                        diagnostics.push(diagnostic('APP_CONFIG_DATA_RESOURCE_SOURCE_BINDING_FIELD_NOT_FOUND', `动态来源绑定字段 ${bindingField} 未在当前资源声明`, `${sourcePath}.filters[${filterIndex}].binding.field`));
+                    }
+                });
             });
         });
     }
@@ -514,10 +675,10 @@ export function validateAppConfig(value) {
                 if (!declaredFieldTypes) {
                     diagnostics.push(diagnostic('APP_CONFIG_AUTHZ_DIMENSION_VALUE_SOURCE_RESOURCE_INVALID', 'native_resource valueSource 必须引用同一应用内已声明的 Data Resource', `${valueSourcePath}.resourceCode`));
                 }
-                else if (!['string', 'text'].includes(declaredFieldTypes.get(labelField) || '') ||
+                else if (!['text.short', 'text.long', 'serial-number'].includes(declaredFieldTypes.get(labelField) || '') ||
                     (enabledField !== undefined &&
                         declaredFieldTypes.get(enabledField) !== 'boolean')) {
-                    diagnostics.push(diagnostic('APP_CONFIG_AUTHZ_DIMENSION_VALUE_SOURCE_FIELD_INVALID', 'valueSource 标签字段必须为 string/text，启用字段必须为 boolean', valueSourcePath));
+                    diagnostics.push(diagnostic('APP_CONFIG_AUTHZ_DIMENSION_VALUE_SOURCE_FIELD_INVALID', 'valueSource 标签字段必须为文本/流水号，启用字段必须为 boolean', valueSourcePath));
                 }
             }
             dimensionCodes.add(code);
@@ -541,7 +702,7 @@ export function validateAppConfig(value) {
                 !string(source.name) ||
                 !/^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/.test(resourceCode) ||
                 !['user', 'role_membership'].includes(subjectType) ||
-                !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(string(subject.userIdField)) ||
+                !SEMANTIC_FIELD_PATH_PATTERN.test(string(subject.userIdField)) ||
                 (subjectType === 'role_membership' && !roleCodes.has(roleCode)) ||
                 (subjectType === 'user' && Boolean(roleCode)) ||
                 grants.length === 0 ||
@@ -554,9 +715,9 @@ export function validateAppConfig(value) {
                 const dimensionCode = string(grant.dimensionCode);
                 if (!dimensionCodes.has(dimensionCode) ||
                     grantDimensions.has(dimensionCode) ||
-                    !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(string(grant.valueField)) ||
+                    !SEMANTIC_FIELD_PATH_PATTERN.test(string(grant.valueField)) ||
                     (grant.parentValueField !== undefined &&
-                        !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(string(grant.parentValueField)))) {
+                        !SEMANTIC_FIELD_PATH_PATTERN.test(string(grant.parentValueField)))) {
                     diagnostics.push(diagnostic('APP_CONFIG_AUTHZ_SCOPE_SOURCE_GRANT_INVALID', 'scope source grant 必须引用唯一已声明维度及有效字段', `${sourcePath}.grants[${grantIndex}]`));
                 }
                 grantDimensions.add(dimensionCode);
@@ -593,7 +754,7 @@ export function validateAppConfig(value) {
                     .map(string),
             ];
             if (!declaredFields ||
-                referencedFields.some(field => !declaredFields.has(field))) {
+                referencedFields.some(field => !declaredFields.has(semanticFieldPathRoot(field)))) {
                 diagnostics.push(diagnostic('APP_CONFIG_AUTHZ_SCOPE_SOURCE_RESOURCE_INVALID', 'scope source 必须引用已声明 Data Resource 及其真实字段', sourcePath));
             }
             sourceCodes.add(code);
@@ -611,6 +772,9 @@ export function validateAppConfig(value) {
                 diagnostics.push(diagnostic('APP_CONFIG_AUTHZ_POLICY_INVALID', 'data policy 必须声明唯一 code、name、matchMode 和至少一条规则', `authz.dataPolicies[${index}]`));
             }
             policyCodes.add(code);
+            if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(string(policy.resourceCode))) {
+                diagnostics.push(diagnostic('APP_CONFIG_AUTHZ_POLICY_RESOURCE_REQUIRED', 'data policy 必须声明唯一目标 resourceCode', `authz.dataPolicies[${index}].resourceCode`));
+            }
             if (policy.unrestrictedRoleCodes !== undefined) {
                 const unrestrictedRoleCodes = Array.isArray(policy.unrestrictedRoleCodes)
                     ? policy.unrestrictedRoleCodes
@@ -683,10 +847,80 @@ export function validateAppConfig(value) {
                 diagnostics.push(diagnostic('APP_CONFIG_AUTHZ_DATA_POLICY_NOT_FOUND', `DataResource 引用了未声明的数据策略: ${policyCode}`, `data.resources[${index}].dataPolicyCode`));
             }
         });
+        diagnostics.push(...validateAuthzSemanticBindings({
+            resources: dataResources,
+            dimensions,
+            scopeSources,
+            policies,
+        }));
         validateAuthorizationTransitions(authz.authorizationTransitions, roleCodes, diagnostics);
     }
     validateCapabilityClosure(appCode, config, declaredCapabilities, diagnostics);
     const events = object(config.events);
+    const eventDataResources = Array.isArray(object(config.data).resources)
+        ? object(config.data).resources
+        : [];
+    const eventResourceFields = new Map(eventDataResources.map(rawResource => {
+        const resource = object(rawResource);
+        const fields = Array.isArray(object(resource.schema).fields)
+            ? object(resource.schema).fields
+            : [];
+        return [
+            string(resource.code),
+            new Map(fields.map(rawField => {
+                const field = object(rawField);
+                return [string(field.code), string(field.type)];
+            })),
+        ];
+    }));
+    const platformEventTypes = new Set(PLATFORM_EVENT_TYPES_V2);
+    const declaredEventTypes = new Set();
+    const applicationEventSchemas = new Map();
+    const schemaKeys = new Set();
+    (Array.isArray(events.schemas) ? events.schemas : []).forEach((item, index) => {
+        const schema = object(item);
+        const path = `events.schemas[${index}]`;
+        const eventType = string(schema.eventType);
+        const dataSchemaVersion = string(schema.dataSchemaVersion);
+        const jsonSchema = object(schema.jsonSchema);
+        const sensitiveFields = Array.isArray(schema.sensitiveFields)
+            ? schema.sensitiveFields.map(value => string(value))
+            : [];
+        const sensitiveFieldsValid = (schema.sensitiveFields === undefined ||
+            Array.isArray(schema.sensitiveFields)) &&
+            sensitiveFields.length <= 100 &&
+            new Set(sensitiveFields).size === sensitiveFields.length &&
+            sensitiveFields.every(field => /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*){0,7}$/.test(field) && eventSchemaDeclaresPath(jsonSchema, field));
+        const schemaKey = `${eventType}:${dataSchemaVersion}`;
+        let schemaBytes = Number.POSITIVE_INFINITY;
+        try {
+            schemaBytes = Buffer.byteLength(JSON.stringify(schema.jsonSchema), 'utf8');
+        }
+        catch {
+            // Reported by the combined validation below.
+        }
+        const schemaValid = !(!EVENT_TYPE_PATTERN.test(eventType) ||
+            eventType.startsWith('openxiangda.') ||
+            !eventType.startsWith(`${appCode}.`) ||
+            !EVENT_DATA_SCHEMA_VERSION_PATTERN.test(dataSchemaVersion) ||
+            object(schema.jsonSchema) !== schema.jsonSchema ||
+            jsonSchema.type !== 'object' ||
+            schemaBytes > 256 * 1024 ||
+            !sensitiveFieldsValid ||
+            schemaKeys.has(schemaKey) ||
+            declaredEventTypes.has(eventType));
+        if (!schemaValid) {
+            diagnostics.push(diagnostic('APP_CONFIG_EVENT_SCHEMA_INVALID', '应用事件 Schema 必须使用 appCode 命名空间、major 事件类型、SemVer dataSchemaVersion、不超过 256 KiB 的 object JSON Schema；sensitiveFields 最多 100 个、路径规范且必须指向已声明字段，且版本不可重复', path));
+        }
+        if (schemaValid) {
+            declaredEventTypes.add(eventType);
+            applicationEventSchemas.set(eventType, jsonSchema);
+        }
+        schemaKeys.add(schemaKey);
+    });
+    const allowedEventTypes = new Set([...platformEventTypes, ...declaredEventTypes]);
+    const captureFieldsByResource = new Map();
+    const subscriptionCodes = new Set();
     if (config.events !== undefined && !Array.isArray(events.subscriptions)) {
         diagnostics.push(diagnostic('APP_CONFIG_EVENT_SUBSCRIPTIONS_REQUIRED', 'events.subscriptions 必须是数组', 'events.subscriptions'));
     }
@@ -697,34 +931,154 @@ export function validateAppConfig(value) {
             if ('environmentKey' in subscription) {
                 diagnostics.push(diagnostic('APP_CONFIG_ENVIRONMENT_OVERRIDE_FORBIDDEN', '事件声明属于环境中立 AppVersion，不能声明 environmentKey', `${path}.environmentKey`));
             }
-            if (!/^[a-z][a-z0-9-]*$/.test(string(subscription.code))) {
-                diagnostics.push(diagnostic('APP_CONFIG_EVENT_SUBSCRIPTION_CODE_INVALID', '事件订阅 code 必须是 kebab-case', `${path}.code`));
+            const subscriptionCode = string(subscription.code);
+            if (!/^[a-z][a-z0-9-]*$/.test(subscriptionCode) ||
+                subscriptionCodes.has(subscriptionCode)) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_SUBSCRIPTION_CODE_INVALID', '事件订阅 code 必须是唯一的 kebab-case', `${path}.code`));
             }
             if (!Array.isArray(subscription.eventTypes) ||
-                subscription.eventTypes.length === 0) {
-                diagnostics.push(diagnostic('APP_CONFIG_EVENT_TYPES_REQUIRED', '事件订阅必须声明 eventTypes', `${path}.eventTypes`));
+                subscription.eventTypes.length === 0 ||
+                subscription.eventTypes.length > 20 ||
+                new Set(subscription.eventTypes.map(string)).size !==
+                    subscription.eventTypes.length ||
+                subscription.eventTypes.some(eventType => !allowedEventTypes.has(string(eventType)))) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_TYPES_INVALID', '事件订阅必须声明 1 到 20 个不重复且已注册的 v2 eventTypes', `${path}.eventTypes`));
+            }
+            if ('endpointPath' in subscription) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_ENDPOINT_DECLARATION_FORBIDDEN', '事件订阅 endpointPath 由 code 生成，应用不能重复声明', `${path}.endpointPath`));
             }
-            const endpointPath = string(subscription.endpointPath);
-            if (!endpointPath.startsWith('/') ||
-                endpointPath.startsWith('//') ||
-                endpointPath.includes('..')) {
-                diagnostics.push(diagnostic('APP_CONFIG_EVENT_ENDPOINT_INVALID', '事件订阅 endpointPath 必须是应用后端相对路径', `${path}.endpointPath`));
+            subscriptionCodes.add(subscriptionCode);
+            const filter = object(subscription.filter);
+            const filterKeys = Object.keys(filter);
+            const resourceCodes = Array.isArray(filter.resourceCodes)
+                ? filter.resourceCodes.map(string)
+                : [];
+            if (filterKeys.some(key => !['resourceCodes', 'subject', 'changedFields', 'changes', 'where'].includes(key)) ||
+                resourceCodes.length > 20 ||
+                new Set(resourceCodes).size !== resourceCodes.length ||
+                resourceCodes.some(code => !eventResourceFields.has(code))) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_RESOURCE_INVALID', '事件过滤 resourceCodes 必须引用最多 20 个不重复的已声明资源', `${path}.filter`));
+            }
+            const allowedFields = new Set();
+            if (resourceCodes.length > 0) {
+                const fieldSets = resourceCodes
+                    .map(code => eventResourceFields.get(code))
+                    .filter(Boolean);
+                for (const field of fieldSets[0]?.keys() || []) {
+                    if (fieldSets.every(fields => fields.has(field)))
+                        allowedFields.add(field);
+                }
+            }
+            const subject = object(filter.subject);
+            if (Object.keys(subject).length > 1 ||
+                Object.keys(subject).some(key => !['equals', 'prefix'].includes(key)) ||
+                Object.values(subject).some(value => typeof value !== 'string')) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_SUBJECT_INVALID', 'subject 过滤只能声明 equals 或 prefix 之一', `${path}.filter.subject`));
+            }
+            const referencedFields = new Set();
+            const changedFields = object(filter.changedFields);
+            const filterComplexity = {
+                atoms: (resourceCodes.length > 0 ? 1 : 0) +
+                    (Object.keys(subject).length > 0 ? 1 : 0),
+            };
+            for (const [group, rawFields] of Object.entries(changedFields)) {
+                const fields = Array.isArray(rawFields) ? rawFields.map(string) : [];
+                fields.forEach(field => referencedFields.add(field));
+                if (['anyOf', 'allOf', 'noneOf'].includes(group)) {
+                    filterComplexity.atoms += 1;
+                }
+                if (!['anyOf', 'allOf', 'noneOf'].includes(group) ||
+                    fields.length < 1 ||
+                    fields.length > 32 ||
+                    new Set(fields).size !== fields.length) {
+                    diagnostics.push(diagnostic('APP_CONFIG_EVENT_CHANGED_FIELDS_INVALID', 'changedFields 只支持 anyOf/allOf/noneOf，每组 1 到 32 个不重复字段', `${path}.filter.changedFields.${group}`));
+                }
+            }
+            const changes = Array.isArray(filter.changes) ? filter.changes : [];
+            filterComplexity.atoms += changes.length;
+            if (changes.length > 16) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_CHANGE_FILTERS_EXCEEDED', '单个订阅最多声明 16 个字段变化条件', `${path}.filter.changes`));
+            }
+            changes.forEach((change, changeIndex) => {
+                referencedFields.add(string(object(change).field));
+                validateEventChangeFilter(change, `${path}.filter.changes[${changeIndex}]`, allowedFields, diagnostics);
+            });
+            if (filter.where !== undefined) {
+                validateEventFilterCondition(filter.where, `${path}.filter.where`, allowedFields, diagnostics, filterComplexity);
+            }
+            if (filterComplexity.atoms > 16) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_ATOMS_EXCEEDED', '单个订阅最多包含 16 个原子过滤条件', `${path}.filter`));
+            }
+            const payload = object(subscription.payload);
+            const projectionFields = Array.isArray(payload.fields)
+                ? payload.fields.map(string)
+                : [];
+            projectionFields.forEach(field => referencedFields.add(field));
+            if (Object.keys(payload).some(key => !['includeChanges', 'fields'].includes(key)) ||
+                (payload.includeChanges !== undefined &&
+                    typeof payload.includeChanges !== 'boolean') ||
+                projectionFields.length > 32 ||
+                new Set(projectionFields).size !== projectionFields.length ||
+                referencedFields.size > 0 && resourceCodes.length === 0 ||
+                [...referencedFields].some(field => !allowedFields.has(field))) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_PROJECTION_INVALID', '字段过滤和 payload.fields 必须绑定 resourceCodes、引用各目标资源共有字段，且单订阅投影最多 32 个字段', `${path}.payload`));
+            }
+            for (const resourceCode of resourceCodes) {
+                const captured = captureFieldsByResource.get(resourceCode) || new Set();
+                referencedFields.forEach(field => captured.add(field));
+                captureFieldsByResource.set(resourceCode, captured);
+            }
+            const delivery = {
+                timeoutMs: 10_000,
+                maxAttempts: 8,
+                initialBackoffMs: 1_000,
+                maxBackoffMs: 300_000,
+                ordering: 'none',
+                concurrency: 10,
+                ...object(subscription.delivery),
+            };
+            if (!Number.isInteger(delivery.timeoutMs) ||
+                Number(delivery.timeoutMs) < 1000 ||
+                Number(delivery.timeoutMs) > 30_000 ||
+                !Number.isInteger(delivery.maxAttempts) ||
+                Number(delivery.maxAttempts) < 1 ||
+                Number(delivery.maxAttempts) > 12 ||
+                !Number.isInteger(delivery.initialBackoffMs) ||
+                Number(delivery.initialBackoffMs) < 1000 ||
+                !Number.isInteger(delivery.maxBackoffMs) ||
+                Number(delivery.maxBackoffMs) < Number(delivery.initialBackoffMs) ||
+                Number(delivery.maxBackoffMs) > 1_800_000 ||
+                !['none', 'record'].includes(string(delivery.ordering)) ||
+                !Number.isInteger(delivery.concurrency) ||
+                Number(delivery.concurrency) < 1 ||
+                Number(delivery.concurrency) > 50) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_DELIVERY_POLICY_INVALID', 'delivery 超出 timeout、attempt、backoff、ordering 或 concurrency 的平台上限', `${path}.delivery`));
             }
         });
     }
+    for (const [resourceCode, fields] of captureFieldsByResource) {
+        if (fields.size > 64) {
+            diagnostics.push(diagnostic('APP_CONFIG_EVENT_CAPTURE_PLAN_EXCEEDED', `资源 ${resourceCode} 的订阅捕获字段并集超过 64 个`, 'events.subscriptions'));
+        }
+    }
+    const timerCodes = new Set();
     (Array.isArray(events.timers) ? events.timers : []).forEach((item, index) => {
         const timer = object(item);
         const path = `events.timers[${index}]`;
         if ('environmentKey' in timer) {
             diagnostics.push(diagnostic('APP_CONFIG_ENVIRONMENT_OVERRIDE_FORBIDDEN', '定时声明属于环境中立 AppVersion，不能声明 environmentKey', `${path}.environmentKey`));
         }
-        if (!/^[a-z][a-z0-9-]*$/.test(string(timer.code))) {
+        if (!/^[a-z][a-z0-9-]*$/.test(string(timer.code)) ||
+            timerCodes.has(string(timer.code))) {
             diagnostics.push(diagnostic('APP_CONFIG_TIMER_CODE_INVALID', '定时订阅 code 必须是 kebab-case', `${path}.code`));
         }
-        if (!string(timer.eventType) ||
+        timerCodes.add(string(timer.code));
+        if (!declaredEventTypes.has(string(timer.eventType)) ||
             !string(timer.cronExpression) ||
-            !string(timer.timezone)) {
-            diagnostics.push(diagnostic('APP_CONFIG_TIMER_SCHEDULE_REQUIRED', '定时订阅必须声明 eventType、六段 cronExpression 和 IANA timezone', path));
+            !string(timer.timezone) ||
+            (timer.misfirePolicy !== undefined &&
+                timer.misfirePolicy !== 'coalesce_one')) {
+            diagnostics.push(diagnostic('APP_CONFIG_TIMER_SCHEDULE_REQUIRED', '定时订阅必须引用应用事件 Schema，并声明六段 cronExpression、IANA timezone 和 coalesce_one misfire policy', path));
         }
         const cronExpression = string(timer.cronExpression);
         const timezone = string(timer.timezone);
@@ -754,6 +1108,49 @@ export function validateAppConfig(value) {
         else if (Buffer.byteLength(JSON.stringify(timer.payload || {}), 'utf8') > 64 * 1024) {
             diagnostics.push(diagnostic('APP_CONFIG_TIMER_PAYLOAD_TOO_LARGE', '定时事件 payload 不能超过 64 KiB', `${path}.payload`));
         }
+        else if (!eventDataMatchesSchema(applicationEventSchemas.get(string(timer.eventType)), timer.payload)) {
+            diagnostics.push(diagnostic('APP_CONFIG_TIMER_PAYLOAD_SCHEMA_INVALID', '定时事件 payload 必须完整满足所引用的应用事件 JSON Schema', `${path}.payload`));
+        }
+    });
+    const dateTriggerCodes = new Set();
+    (Array.isArray(events.dateTriggers) ? events.dateTriggers : []).forEach((item, index) => {
+        const trigger = object(item);
+        const path = `events.dateTriggers[${index}]`;
+        const code = string(trigger.code);
+        const resourceCode = string(trigger.resourceCode);
+        const field = string(trigger.field);
+        const fieldType = eventResourceFields.get(resourceCode)?.get(field);
+        const payload = object(trigger.payload);
+        let payloadBytes = Number.POSITIVE_INFINITY;
+        try {
+            payloadBytes = Buffer.byteLength(JSON.stringify(trigger.payload || {}), 'utf8');
+        }
+        catch {
+            // Reported by the combined validation below.
+        }
+        if (!/^[a-z][a-z0-9-]*$/.test(code) ||
+            dateTriggerCodes.has(code) ||
+            !eventResourceFields.has(resourceCode) ||
+            !['date', 'datetime'].includes(fieldType || '') ||
+            !validDateTriggerOffset(trigger.offset) ||
+            !declaredEventTypes.has(string(trigger.eventType)) ||
+            trigger.payload === null ||
+            typeof trigger.payload !== 'object' ||
+            Array.isArray(trigger.payload) ||
+            payloadBytes > 64 * 1024 ||
+            Object.keys(payload).some(key => DATE_TRIGGER_RESERVED_DATA_FIELDS.has(key)) ||
+            !eventDataMatchesSchema(applicationEventSchemas.get(string(trigger.eventType)), {
+                ...payload,
+                triggerCode: code,
+                resourceCode,
+                recordId: '00000000-0000-4000-8000-000000000000',
+                recordRevision: 1,
+                field,
+                dueAt: '2026-01-01T00:00:00.000Z',
+            })) {
+            diagnostics.push(diagnostic('APP_CONFIG_DATE_TRIGGER_INVALID', 'dateTrigger 必须使用唯一 code、date/datetime 字段、十年内 ISO-8601 offset、已注册应用事件、无保留字段且完整生成数据满足 JSON Schema', path));
+        }
+        dateTriggerCodes.add(code);
     });
     const workflows = object(config.workflows);
     if (config.workflows !== undefined &&
@@ -1288,14 +1685,29 @@ export function currentUserDataPolicy(input) {
 }
 export function materializeDataResource(appCode, declaration) {
     const capabilities = resourceCapabilityCodes(appCode, declaration.code);
-    const fields = declaration.fields.map(field => ({
-        code: field.code,
-        type: field.type,
-        nullable: field.required !== true,
-        ...(field.indexed !== undefined ? { indexed: field.indexed } : {}),
-        ...(field.reference ? { reference: field.reference } : {}),
-        ...(field.file ? { file: field.file } : {}),
-    }));
+    const fields = declaration.fields.map(field => {
+        const definition = {
+            code: field.code,
+            type: field.type,
+            nullable: fieldNullable({
+                type: field.type,
+                nullable: field.required !== true,
+            }),
+            indexed: field.indexed ??
+                Boolean(field.filter || field.searchable || field.sortable),
+            ...(field.options ? { options: field.options } : {}),
+            ...(field.source ? { source: field.source } : {}),
+            ...(field.maxLength !== undefined ? { maxLength: field.maxLength } : {}),
+            ...(field.precision !== undefined ? { precision: field.precision } : {}),
+            ...(field.scale !== undefined ? { scale: field.scale } : {}),
+            ...(field.timePrecision ? { timePrecision: field.timePrecision } : {}),
+            ...(field.file ? { file: field.file } : {}),
+            ...(field.serial ? { serial: field.serial } : {}),
+            ...(field.subtable ? { subtable: field.subtable } : {}),
+        };
+        physicalPlanForField(definition, field.searchable === true);
+        return definition;
+    });
     const visible = declaration.fields
         .filter(field => field.list !== false)
         .slice(0, 8);
@@ -1306,6 +1718,8 @@ export function materializeDataResource(appCode, declaration) {
         .filter(field => field.filter === true)
         .map(field => field.code);
     const access = (field, operation) => {
+        if (isGeneratedField(field.type) && operation !== 'read')
+            return [];
         const override = field.access?.[operation];
         if (override === false)
             return [];
@@ -1319,6 +1733,7 @@ export function materializeDataResource(appCode, declaration) {
             field.code,
             {
                 label: field.label,
+                type: field.type,
                 widget: resolveDataFieldSurfaceWidget(field),
                 ...(field.section ? { section: field.section } : {}),
                 ...(field.required === true ? { requiredHint: true } : {}),
@@ -1326,16 +1741,21 @@ export function materializeDataResource(appCode, declaration) {
                 readCapabilities: access(field, 'read'),
                 createCapabilities: access(field, 'create'),
                 updateCapabilities: access(field, 'update'),
-                ...(field.reference?.multiple !== undefined
-                    ? { multiple: field.reference.multiple }
-                    : field.file?.multiple !== undefined
-                        ? { multiple: field.file.multiple }
-                        : {}),
+                ...(field.maxLength !== undefined ? { maxLength: field.maxLength } : {}),
+                ...(field.precision !== undefined ? { precision: field.precision } : {}),
+                ...(field.scale !== undefined ? { scale: field.scale } : {}),
                 ...(field.file?.maxCount !== undefined
                     ? { maxCount: field.file.maxCount }
                     : {}),
+                ...(field.file?.maxSizeMb !== undefined
+                    ? { maxSizeMb: field.file.maxSizeMb }
+                    : {}),
                 ...(field.file?.accept ? { accept: field.file.accept } : {}),
                 ...(field.options ? { options: field.options } : {}),
+                ...(field.source ? { source: field.source } : {}),
+                ...(field.timePrecision ? { timePrecision: field.timePrecision } : {}),
+                ...(field.serial ? { serial: field.serial } : {}),
+                ...(field.subtable ? { subtable: field.subtable } : {}),
                 ...(visible.some(item => item.code === field.code)
                     ? { list: true }
                     : { list: false }),
@@ -1343,7 +1763,6 @@ export function materializeDataResource(appCode, declaration) {
                     ? { searchable: field.searchable }
                     : {}),
                 ...(field.sortable !== undefined ? { sortable: field.sortable } : {}),
-                ...(field.reference ? { reference: field.reference } : {}),
             },
         ])),
         list: {
@@ -1404,8 +1823,15 @@ export function validateAppDeclaration(value) {
         'label',
         'required',
         'indexed',
-        'reference',
+        'options',
+        'source',
+        'maxLength',
+        'precision',
+        'scale',
+        'timePrecision',
         'file',
+        'serial',
+        'subtable',
         'widget',
         'section',
         'system',
@@ -1413,7 +1839,6 @@ export function validateAppDeclaration(value) {
         'filter',
         'searchable',
         'sortable',
-        'options',
         'access',
     ]);
     resources.forEach((rawResource, resourceIndex) => {
@@ -1443,7 +1868,34 @@ export function validateAppDeclaration(value) {
             const fieldType = string(field.type);
             if (!APP_DATA_FIELD_TYPES.has(fieldType)) {
                 materializable = false;
-                diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_TYPE_INVALID', `${fieldPath}.type 必须是 string、text、integer、decimal、boolean、date、datetime、uuid、json 或 file`, `${fieldPath}.type`, '数字字段使用 integer 或 decimal，不存在 number 类型'));
+                diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_TYPE_INVALID', `${fieldPath}.type 必须是 OpenXiangda 2.0 语义字段类型之一: ${DATA_FIELD_TYPES.join('、')}`, `${fieldPath}.type`, '直接声明业务语义类型，不声明 PostgreSQL 物理类型'));
+            }
+            else {
+                const semanticType = fieldType;
+                const widget = string(field.widget);
+                if (widget && !isCompatibleFieldWidget({ type: semanticType, widget })) {
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_WIDGET_INCOMPATIBLE', `${fieldPath}.widget 与 ${semanticType} 不兼容；允许 ${compatibleWidgets(semanticType).join('、')}`, `${fieldPath}.widget`));
+                }
+                if (field.filter === true && !supportsFilter(semanticType)) {
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_FILTER_UNSUPPORTED', `${semanticType} 不支持作为父资源筛选字段`, `${fieldPath}.filter`));
+                }
+                if (field.searchable === true && !supportsSearch(semanticType)) {
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_SEARCH_UNSUPPORTED', `${semanticType} 没有全文/模糊搜索和 trigram 索引计划`, `${fieldPath}.searchable`));
+                }
+                if (field.sortable === true && !supportsSort(semanticType)) {
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_SORT_UNSUPPORTED', `${semanticType} 不支持稳定排序`, `${fieldPath}.sortable`));
+                }
+                if (field.indexed === false &&
+                    (field.filter === true ||
+                        field.searchable === true ||
+                        field.sortable === true)) {
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_INDEX_REQUIRED', '启用筛选、搜索或排序时不能显式关闭索引', `${fieldPath}.indexed`));
+                }
+                if (['radio', 'checkbox'].includes(widget) &&
+                    object(field.source).loadMode !== 'all' &&
+                    field.source !== undefined) {
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_SOURCE_LOAD_MODE_INVALID', '动态 Radio/Checkbox 必须声明 source.loadMode = all', `${fieldPath}.source.loadMode`));
+                }
             }
             if (!string(field.label)) {
                 diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_LABEL_REQUIRED', '字段必须同时声明中文或业务 label', `${fieldPath}.label`));
@@ -1493,6 +1945,63 @@ export function validateAppDeclaration(value) {
             })));
         }
     });
+    const declaredResources = new Map(resources.map((rawResource, resourceIndex) => {
+        const resource = object(rawResource);
+        return [
+            string(resource.code),
+            {
+                resource,
+                resourceIndex,
+                fields: new Map((Array.isArray(resource.fields) ? resource.fields : []).map(rawField => {
+                    const field = object(rawField);
+                    return [string(field.code), field];
+                })),
+            },
+        ];
+    }));
+    for (const [resourceCode, declaration] of declaredResources) {
+        const fields = Array.isArray(declaration.resource.fields)
+            ? declaration.resource.fields
+            : [];
+        const aggregateMaxRows = fields.reduce((total, rawField) => {
+            const field = object(rawField);
+            if (field.type !== 'subtable')
+                return total;
+            const configured = Number(object(field.subtable).maxRows);
+            return total + (Number.isSafeInteger(configured) ? configured : 20);
+        }, 0);
+        if (aggregateMaxRows > 49) {
+            diagnostics.push(diagnostic('APP_CONFIG_DATA_SUBTABLE_AGGREGATE_MAX_ROWS_EXCEEDED', '同一父资源的所有子表 maxRows 总和不能超过 49', `data.resources[${declaration.resourceIndex}].fields`));
+        }
+        fields.forEach((rawField, fieldIndex) => {
+            const field = object(rawField);
+            if (field.type !== 'subtable')
+                return;
+            const path = `data.resources[${declaration.resourceIndex}].fields[${fieldIndex}].subtable`;
+            const subtable = object(field.subtable);
+            const targetCode = string(subtable.resourceCode);
+            const target = declaredResources.get(targetCode);
+            if (!target || targetCode === resourceCode) {
+                diagnostics.push(diagnostic('APP_CONFIG_DATA_SUBTABLE_TARGET_INVALID', '子表必须引用同一应用内不同的子资源', `${path}.resourceCode`));
+                return;
+            }
+            const foreignKey = target.fields.get(string(subtable.foreignKey));
+            if (!foreignKey ||
+                foreignKey.type !== 'uuid' ||
+                foreignKey.required !== true ||
+                object(foreignKey.access).create === false) {
+                diagnostics.push(diagnostic('APP_CONFIG_DATA_SUBTABLE_FOREIGN_KEY_INVALID', '子表外键必须是子资源中可创建写入的必填 uuid 字段', `${path}.foreignKey`));
+            }
+            const orderField = target.fields.get(string(subtable.orderField));
+            if (!orderField ||
+                orderField.type !== 'number.integer' ||
+                orderField.required !== true ||
+                object(orderField.access).create === false ||
+                object(orderField.access).update === false) {
+                diagnostics.push(diagnostic('APP_CONFIG_DATA_SUBTABLE_ORDER_FIELD_INVALID', '子表排序字段必须是子资源中可创建和更新的必填 number.integer 字段', `${path}.orderField`));
+            }
+        });
+    }
     return diagnostics;
 }
 export function defineOpenXiangdaApp(declaration) {