openyida 2026.8.31 → 2026.9.1

package/lib/app/create-app.js

@@ -269,6 +269,7 @@ function buildCreateAppPayload(params, auth, contentLocale, openExclusive, openP
     openPhysicColumn,
     openIsolationDatabase: 'n',
     openExclusiveUnit: 'n',
+    createWithModernTheme: 'y',
     group: 'ALL',
     fromBuilderAi: 'y',
     builderAiSource: resolveBuilderAiSource(),

package/lib/app/create-form.js

@@ -84,6 +84,13 @@ const { dispatchCreateFormCommand } = require('./create-form/commands');
 const { buildApiPath } = require('./create-form/api-path');
 const { deepMerge, splitJsonPointer } = require('./create-form/schema-patch');
 const { ensureYidaGlobalThemeAction } = require('./form-theme-action');
+const {
+  actionRefName,
+  buildDesignerEventBinding,
+  extractExportedActionFunctionNames,
+  inspectActionBindings,
+  syncDesignerActionCatalog,
+} = require('./form-action-binding');
 const { FORM_RULES_BLOCK_END, FORM_RULES_BLOCK_START } = require('./create-form/rule-builder');
 const { SMART_VALIDATION_BLOCK_END, SMART_VALIDATION_BLOCK_START } = require('./create-form/validation-builder');
 const { createFieldNormalizers } = require('./create-form/field-normalizers');
@@ -2678,6 +2685,116 @@ function compileActionSource(source) {
   return compiledResult.compiled;
 }
 
+function bindFieldAction(schema, formContainer, operation) {
+  if (!formContainer || !formContainer.children) {
+    throw new Error('未找到 FormContainer');
+  }
+  const fieldKey = operation.fieldId || operation.field || operation.label;
+  const eventName = operation.event || 'onChange';
+  const actionName = operation.name || operation.actionName;
+  if (!actionName) {
+    throw new Error('bind-field-action 必须提供 name/actionName');
+  }
+  if (!isValidActionIdentifier(actionName)) {
+    throw new Error('动作名称不是合法的 JavaScript 标识符: ' + actionName);
+  }
+  const found = findFieldByIdOrLabelDeep(formContainer.children, fieldKey);
+  if (!found) {
+    throw new Error('未找到字段: ' + fieldKey);
+  }
+  found.field.props = found.field.props || {};
+  const existingActionName = actionRefName(found.field.props[eventName]);
+  if (existingActionName && existingActionName !== actionName && operation.replaceExisting !== true) {
+    throw createCreateFormError(
+      t('create_form.action_event_conflict', fieldKey, eventName, existingActionName),
+      'FORM_ACTION_EVENT_CONFLICT',
+      {
+        status: 'SEMANTIC_FAILURE',
+        retryable: false,
+        sideEffectState: 'none',
+        nextStep: 'review_existing_field_action',
+        field: fieldKey,
+        event: eventName,
+        existingActionName,
+        requestedActionName: actionName,
+      }
+    );
+  }
+
+  found.field.props[eventName] = buildDesignerEventBinding(
+    actionName,
+    operation.params || {},
+    found.field.props[eventName]
+  );
+
+  const actions = ensureActionModule(schema);
+  const fieldId = found.field.props.fieldId || found.field.id || String(fieldKey || '');
+  const relatedEventId = operation.relatedEventId || ((found.field.id || fieldId) + ':' + eventName);
+  syncDesignerActionCatalog(actions);
+
+  return {
+    action: operation.action === 'field-action' ? 'field-action' : 'bind-field-action',
+    field: fieldKey,
+    fieldId,
+    event: eventName,
+    actionName,
+    relatedEventId,
+    replacedActionName: existingActionName && existingActionName !== actionName ? existingActionName : '',
+  };
+}
+
+function applyAtomicFieldAction(schema, formContainer, operation) {
+  const actionName = operation.name || operation.actionName;
+  if (!actionName) {
+    throw new Error('field-action 必须提供 name/actionName');
+  }
+  if (!isValidActionIdentifier(actionName)) {
+    throw new Error('动作名称不是合法的 JavaScript 标识符: ' + actionName);
+  }
+
+  const actions = ensureActionModule(schema);
+  const source = readOptionalSource(operation, 'source', 'sourceFile');
+  if (source !== undefined) {
+    if (!extractExportedActionFunctionNames(source).includes(actionName)) {
+      throw createCreateFormError(
+        t('create_form.action_source_export_missing', actionName),
+        'FORM_ACTION_FUNCTION_MISSING',
+        {
+          status: 'SEMANTIC_FAILURE',
+          retryable: false,
+          sideEffectState: 'none',
+          nextStep: 'export_named_action_function',
+          actionName,
+        }
+      );
+    }
+    const blockStart = '/* openyida:field-action:start:' + actionName + ' */';
+    const blockEnd = '/* openyida:field-action:end:' + actionName + ' */';
+    actions.module.source = upsertGeneratedSourceBlockWithBounds(
+      actions.module.source || '',
+      source,
+      blockStart,
+      blockEnd
+    );
+    actions.module.compiled = compileActionSource(actions.module.source);
+    actions.type = actions.type || 'FUNCTION';
+  } else if (!extractExportedActionFunctionNames(actions.module.source || '').includes(actionName)) {
+    throw createCreateFormError(
+      t('create_form.action_source_missing', actionName),
+      'FORM_ACTION_FUNCTION_MISSING',
+      {
+        status: 'SEMANTIC_FAILURE',
+        retryable: false,
+        sideEffectState: 'none',
+        nextStep: 'provide_action_source',
+        actionName,
+      }
+    );
+  }
+
+  return bindFieldAction(schema, formContainer, Object.assign({}, operation, { action: 'field-action' }));
+}
+
 function readOptionalSource(operation, key, fileKey) {
   if (operation[fileKey]) {
     const sourcePath = path.resolve(operation[fileKey]);
@@ -2773,6 +2890,11 @@ function applySchemaPatchOperations(schema, operations) {
       return;
     }
 
+    if (action === 'field-action') {
+      applied.push(applyAtomicFieldAction(schema, formContainer, operation));
+      return;
+    }
+
     if (['bind-datasource', 'data-source', 'datasource', 'select-datasource'].includes(String(action).toLowerCase())) {
       if (!formContainer || !formContainer.children) {
         throw new Error('未找到 FormContainer');
@@ -2802,42 +2924,7 @@ function applySchemaPatchOperations(schema, operations) {
     }
 
     if (action === 'bind-field-action') {
-      if (!formContainer || !formContainer.children) {
-        throw new Error('未找到 FormContainer');
-      }
-      const fieldKey = operation.fieldId || operation.field || operation.label;
-      const eventName = operation.event || 'onChange';
-      const actionName = operation.name || operation.actionName;
-      if (!actionName) {
-        throw new Error('bind-field-action 必须提供 name/actionName');
-      }
-      const found = findFieldByIdOrLabelDeep(formContainer.children, fieldKey);
-      if (!found) {
-        throw new Error('未找到字段: ' + fieldKey);
-      }
-      found.field.props = found.field.props || {};
-      found.field.props[eventName] = {
-        name: actionName,
-        id: actionName,
-        params: operation.params || {},
-        type: 'actionRef',
-      };
-
-      const actions = ensureActionModule(schema);
-      const relatedEventId = operation.relatedEventId || (found.field.id + ':' + eventName);
-      const existing = actions.list.find(function (item) {
-        return item.relatedEventId === relatedEventId && item.id === actionName;
-      });
-      if (!existing) {
-        actions.list.push({
-          relatedEventId,
-          name: actionName,
-          id: actionName,
-          type: 'componentEvent',
-          params: operation.params || {},
-        });
-      }
-      applied.push({ action: 'bind-field-action', field: fieldKey, event: eventName, actionName });
+      applied.push(bindFieldAction(schema, formContainer, operation));
       return;
     }
 
@@ -3246,18 +3333,71 @@ function upsertActionListEntry(actions, entry) {
   actions.list.push(entry);
 }
 
+function removeObsoleteGeneratedRuleCatalogEntries(actions, activeActionNames) {
+  // Only prune OpenYida-owned rule wrappers; unknown user/platform entries must survive catalog sync.
+  const activeNames = new Set(activeActionNames || []);
+  actions.list = (actions.list || []).filter(function (item) {
+    const names = [item && item.id, item && item.name].filter(Boolean).map(String);
+    const generatedNames = names.filter(function (name) {
+      return name.startsWith('openyidaRuleChange_');
+    });
+    return generatedNames.length === 0 || generatedNames.some(function (name) {
+      return activeNames.has(name);
+    });
+  });
+}
+
+function previousRuleActionName(source, wrapperName) {
+  const start = String(source || '').indexOf('export function ' + wrapperName + '(');
+  if (start === -1) {return '';}
+  const end = String(source || '').indexOf('return this.openyidaApplyRules', start);
+  const wrapperSource = String(source || '').slice(start, end === -1 ? undefined : end);
+  const match = wrapperSource.match(/typeof this\.([A-Za-z_$][A-Za-z0-9_$]*) === ["']function["']/);
+  return match ? match[1] : '';
+}
+
+function reconcileGeneratedRuleBindings(value, nextSourceFieldIds, actionsSource) {
+  if (!value) {return;}
+  if (Array.isArray(value)) {
+    value.forEach(function (item) {
+      reconcileGeneratedRuleBindings(item, nextSourceFieldIds, actionsSource);
+    });
+    return;
+  }
+  if (typeof value !== 'object') {return;}
+
+  const props = value.props || {};
+  const fieldId = String(props.fieldId || '');
+  const existingActionName = actionRefName(props.onChange);
+  if (fieldId && existingActionName.startsWith('openyidaRuleChange_') && !nextSourceFieldIds.has(fieldId)) {
+    const previousActionName = previousRuleActionName(actionsSource, existingActionName);
+    if (previousActionName) {
+      props.onChange = buildDesignerEventBinding(previousActionName, {}, props.onChange);
+    } else {
+      delete props.onChange;
+    }
+  }
+
+  Object.values(value).forEach(function (child) {
+    if (child !== props) {
+      reconcileGeneratedRuleBindings(child, nextSourceFieldIds, actionsSource);
+    }
+  });
+}
+
 function buildFormRulesActionSource(rules, fieldMap, bindings) {
   const rulesJson = JSON.stringify(rules, null, 2);
   const fieldMapJson = JSON.stringify(fieldMap, null, 2);
   const wrapperSource = bindings.map(function (binding) {
     const previousCall = binding.previousActionName && isValidActionIdentifier(binding.previousActionName)
-      ? '  if (typeof ' + binding.previousActionName + ' === "function") {\n    ' + binding.previousActionName + '.call(this, event);\n  }\n'
+      ? '  if (typeof this.' + binding.previousActionName + ' === "function") {\n    this.' + binding.previousActionName + '(event);\n  }\n'
       : '';
-    return 'export function ' + binding.wrapperName + '(event) {\n' +
+    const title = binding.label ? '/** @title ' + binding.label + '值发生变化 */\n' : '';
+    return title + 'export function ' + binding.wrapperName + '(event) {\n' +
       '  event = event || {};\n' +
       '  event.__openyidaSourceFieldId = "' + binding.fieldId + '";\n' +
       previousCall +
-      '  return openyidaApplyRules.call(this, event);\n' +
+      '  return this.openyidaApplyRules(event);\n' +
       '}';
   }).join('\n\n');
 
@@ -3405,10 +3545,10 @@ export function openyidaApplyRules(event) {
 }
 
 export function openyidaRulesDidMount(event) {
-  if (typeof didMount === 'function') {
-    didMount.call(this, event);
+  if (typeof this.didMount === 'function') {
+    this.didMount(event);
   }
-  return openyidaApplyRules.call(this, event || {});
+  return this.openyidaApplyRules(event || {});
 }
 
 ${wrapperSource}
@@ -3434,6 +3574,8 @@ function applyFormRules(schema, rawRules) {
     }
   });
 
+  reconcileGeneratedRuleBindings(formContainer.children, sourceFieldIds, actions.module.source || '');
+
   const bindings = [];
   sourceFieldIds.forEach(function (fieldId) {
     const found = findFieldByIdOrLabelDeep(formContainer.children, fieldId);
@@ -3443,32 +3585,18 @@ function applyFormRules(schema, rawRules) {
     found.field.props = found.field.props || {};
     const eventName = 'onChange';
     const existingAction = found.field.props[eventName];
-    const previousActionName = existingAction &&
-      existingAction.type === 'actionRef' &&
-      existingAction.name &&
-      !String(existingAction.name).startsWith('openyidaRuleChange_')
-      ? String(existingAction.name)
-      : '';
+    const existingActionName = actionRefName(existingAction);
     const wrapperName = 'openyidaRuleChange_' + sanitizeActionName(fieldId);
+    const previousActionName = existingActionName.startsWith('openyidaRuleChange_')
+      ? previousRuleActionName(actions.module.source || '', existingActionName)
+      : existingActionName;
     const relatedEventId = (found.field.id || fieldId) + ':' + eventName;
 
-    found.field.props[eventName] = {
-      name: wrapperName,
-      id: wrapperName,
-      params: {},
-      type: 'actionRef',
-    };
-
-    actions.list = actions.list.filter(function (item) {
-      return !(item.relatedEventId === relatedEventId && String(item.id || '').startsWith('openyidaRuleChange_'));
-    });
-    upsertActionListEntry(actions, {
-      relatedEventId,
-      name: wrapperName,
-      id: wrapperName,
-      type: 'componentEvent',
-      params: {},
-    });
+    found.field.props[eventName] = buildDesignerEventBinding(
+      wrapperName,
+      {},
+      found.field.props[eventName]
+    );
 
     bindings.push({
       fieldId,
@@ -3516,6 +3644,11 @@ function applyFormRules(schema, rawRules) {
   actions.module.source = upsertGeneratedSourceBlock(actions.module.source || '', generatedSource);
   actions.module.compiled = compileActionSource(actions.module.source);
   actions.type = actions.type || 'FUNCTION';
+  removeObsoleteGeneratedRuleCatalogEntries(actions, bindings.map(function (binding) {
+    return binding.wrapperName;
+  }));
+  // Merge source exports after the rich lifecycle/component entries above so their metadata is preserved.
+  syncDesignerActionCatalog(actions);
 
   return {
     rules: normalized.rules,
@@ -5332,7 +5465,22 @@ async function mainRule(parsedArgs, authRef) {
     fillSerialNumberFormulas(formContainer.children, corpId, appType, formUuid);
   }
 
+  const actionBindingExpectations = applied.bindings.map(function (binding) {
+    return {
+      fieldId: binding.fieldId,
+      event: binding.eventName,
+      actionName: binding.wrapperName,
+      relatedEventId: binding.relatedEventId,
+    };
+  });
+  assertFormActionBindings(schema, actionBindingExpectations);
   await saveFormSchema(authRef, appType, formUuid, schema, version, 4);
+  const actionReadback = await readBackFormActionBindings(
+    authRef,
+    appType,
+    formUuid,
+    actionBindingExpectations
+  );
 
   const formUrl = authRef.baseUrl + '/' + appType + '/workbench/' + formUuid;
   result(true, '表单联动规则保存成功', [
@@ -5347,6 +5495,7 @@ async function mainRule(parsedArgs, authRef) {
       formUuid,
       appType,
       rulesApplied: applied.rules.length,
+      readbackVerified: actionReadback.verified,
       rules: applied.rules.map(function (rule) {
         return {
           type: rule.type,
@@ -5358,11 +5507,16 @@ async function mainRule(parsedArgs, authRef) {
         };
       }),
       eventBindings: applied.bindings.map(function (binding) {
+        const readback = actionReadback.bindings.find(function (item) {
+          return item.fieldId === binding.fieldId && item.event === binding.eventName;
+        });
         return {
           fieldId: binding.fieldId,
           label: binding.label,
           event: binding.eventName,
           actionName: binding.wrapperName,
+          designerBindingFound: readback && readback.designerBindingFound,
+          verified: readback && readback.verified,
           resolved: getFieldEvidenceFromLookup(applied.fieldLookup, binding.fieldId),
         };
       }),
@@ -5376,6 +5530,97 @@ async function mainRule(parsedArgs, authRef) {
 
 // ── patch 模式主流程 ──────────────────────────────────
 
+function actionBindingExpectationsFromOperations(appliedOperations) {
+  return (appliedOperations || []).filter(function (operation) {
+    return operation.action === 'field-action' || operation.action === 'bind-field-action';
+  }).map(function (operation) {
+    return {
+      fieldId: operation.fieldId,
+      event: operation.event,
+      actionName: operation.actionName,
+      relatedEventId: operation.relatedEventId,
+    };
+  });
+}
+
+function assertFormActionBindings(schema, expectations, options) {
+  const inspection = inspectActionBindings(schema, expectations);
+  if (inspection.verified) {
+    return inspection;
+  }
+  const readback = options && options.readback === true;
+  throw createCreateFormError(
+    t(readback ? 'create_form.action_readback_mismatch' : 'create_form.action_binding_incomplete'),
+    readback ? 'FORM_ACTION_BINDING_READBACK_MISMATCH' : 'FORM_ACTION_BINDING_INCOMPLETE',
+    {
+      status: 'SEMANTIC_FAILURE',
+      retryable: false,
+      retrySafe: false,
+      sideEffectState: readback ? 'committed' : 'none',
+      mutationAccepted: readback,
+      readbackVerified: false,
+      readbackAllowed: true,
+      nextStep: readback ? 'inspect_existing_form_action_binding' : 'fix_action_binding_patch',
+      bindings: inspection.bindings,
+    }
+  );
+}
+
+async function readBackFormActionBindings(authRef, appType, formUuid, expectations) {
+  const schemaResult = await requestWithAutoLogin(function (auth) {
+    return sendGetRequest(
+      auth.baseUrl,
+      buildApiPath(appType, 'getFormSchema', { prefix: '_view', namespace: 'alibaba' }),
+      { formUuid: formUuid, schemaVersion: 'V5' }
+    );
+  }, authRef);
+
+  if (!schemaResult || schemaResult.success === false || schemaResult.__needLogin) {
+    const errorMsg = schemaResult ? schemaResult.errorMsg || t('common.unknown_error') : t('common.request_failed');
+    throw createCreateFormError(
+      t('create_form.action_readback_failed', errorMsg),
+      'FORM_ACTION_BINDING_READBACK_FAILED',
+      {
+        status: 'READBACK_UNVERIFIED',
+        retryable: true,
+        retrySafe: false,
+        sideEffectState: 'committed',
+        mutationAccepted: true,
+        readbackVerified: false,
+        readbackAllowed: true,
+        nextStep: 'retry_readback_only',
+        target: { appType, formUuid },
+        result: sanitizeFailureResult(schemaResult),
+      }
+    );
+  }
+
+  let schema;
+  try {
+    schema = schemaResult.content
+      ? (typeof schemaResult.content === 'string' ? JSON.parse(schemaResult.content) : schemaResult.content)
+      : schemaResult;
+  } catch (parseError) {
+    throw createCreateFormError(
+      t('create_form.action_readback_failed', parseError.message),
+      'FORM_ACTION_BINDING_READBACK_FAILED',
+      {
+        status: 'READBACK_UNVERIFIED',
+        retryable: true,
+        retrySafe: false,
+        sideEffectState: 'committed',
+        mutationAccepted: true,
+        readbackVerified: false,
+        readbackAllowed: true,
+        nextStep: 'retry_readback_only',
+        target: { appType, formUuid },
+      }
+    );
+  }
+
+  return assertFormActionBindings(schema, expectations, { readback: true });
+}
+
 async function mainPatch(parsedArgs, authRef) {
   const { appType, formUuid, patchJsonOrFile } = parsedArgs;
 
@@ -5429,6 +5674,9 @@ async function mainPatch(parsedArgs, authRef) {
   try {
     appliedOperations = applySchemaPatchOperations(schema, operations);
   } catch (patchError) {
+    if (patchError && patchError.isCliError) {
+      throw patchError;
+    }
     fail('Schema 补丁应用失败: ' + patchError.message);
     console.log(JSON.stringify({
       success: false,
@@ -5441,6 +5689,10 @@ async function mainPatch(parsedArgs, authRef) {
       formUuid,
     });
   }
+  const actionBindingExpectations = actionBindingExpectationsFromOperations(appliedOperations);
+  const localActionInspection = actionBindingExpectations.length > 0
+    ? assertFormActionBindings(schema, actionBindingExpectations)
+    : null;
   success('已应用 ' + appliedOperations.length + ' 个补丁操作');
   appliedOperations.forEach(function (operation, index) {
     listItem((index + 1) + '. ' + operation.action + (operation.field ? ' ' + operation.field : '') + (operation.path ? ' ' + operation.path : ''));
@@ -5455,6 +5707,9 @@ async function mainPatch(parsedArgs, authRef) {
   }
 
   await saveFormSchema(authRef, appType, formUuid, schema, version, 4);
+  const actionReadback = actionBindingExpectations.length > 0
+    ? await readBackFormActionBindings(authRef, appType, formUuid, actionBindingExpectations)
+    : null;
 
   const formUrl = authRef.baseUrl + '/' + appType + '/workbench/' + formUuid;
   result(true, 'Schema 补丁保存成功', [
@@ -5464,7 +5719,16 @@ async function mainPatch(parsedArgs, authRef) {
   ]);
 
   console.log(JSON.stringify(withBrowserHandoff(
-    { success: true, formUuid, appType, operationsApplied: appliedOperations.length, operations: appliedOperations, url: formUrl },
+    {
+      success: true,
+      formUuid,
+      appType,
+      operationsApplied: appliedOperations.length,
+      operations: appliedOperations,
+      readbackVerified: actionReadback ? actionReadback.verified : undefined,
+      eventBindings: actionReadback ? actionReadback.bindings : (localActionInspection ? localActionInspection.bindings : undefined),
+      url: formUrl,
+    },
     formUrl,
     { stage: 'patch_form_success', title: formUuid },
     parsedArgs.browserOpenMode
@@ -5811,5 +6075,9 @@ module.exports = {
     ensureYidaGlobalThemeAction,
     applyDefaultFormDetailStyle,
     applyChangesToSchema,
+    applyFormRules,
+    applySchemaPatchOperations,
+    actionBindingExpectationsFromOperations,
+    assertFormActionBindings,
   },
 };

package/lib/app/form-action-binding.js

@@ -0,0 +1,185 @@
+'use strict';
+
+let designerEventCounter = 0;
+
+function actionRefs(value) {
+  if (!value || typeof value !== 'object') {
+    return [];
+  }
+  if (value.type === 'JSExpression' && Array.isArray(value.events)) {
+    return value.events.filter(function (event) {
+      return event && event.type === 'actionRef' && (event.name || event.id);
+    });
+  }
+  if (value.type === 'actionRef' && (value.name || value.id)) {
+    return [value];
+  }
+  return [];
+}
+
+function actionRefName(value) {
+  const refs = actionRefs(value);
+  return refs.length > 0 ? String(refs[0].name || refs[0].id || '') : '';
+}
+
+function isDesignerEventBinding(value, actionName) {
+  if (!value || value.type !== 'JSExpression' || !Array.isArray(value.events)) {
+    return false;
+  }
+  const refs = actionRefs(value);
+  if (!refs.some(function (event) {
+    return String(event.name || event.id || '') === String(actionName || '');
+  })) {
+    return false;
+  }
+  const expression = String(value.value || '');
+  return expression.includes('legaoBuiltin.execEventFlow') &&
+    expression.includes('this.' + actionName);
+}
+
+function nextDesignerEventUuid() {
+  designerEventCounter += 1;
+  return String(Date.now()) + '_' + String(designerEventCounter);
+}
+
+function buildDesignerEventBinding(actionName, params, existingValue) {
+  const existingRef = actionRefs(existingValue).find(function (event) {
+    return String(event.name || event.id || '') === String(actionName || '');
+  });
+  return {
+    type: 'JSExpression',
+    value: 'this.utils.legaoBuiltin.execEventFlow.bind(this, [this.' + actionName + '])',
+    events: [{
+      name: actionName,
+      id: actionName,
+      params: params || {},
+      type: 'actionRef',
+      uuid: existingRef && existingRef.uuid || nextDesignerEventUuid(),
+    }],
+  };
+}
+
+function extractExportedActionFunctionNames(source) {
+  const names = [];
+  const pattern = /export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/g;
+  let match;
+  while ((match = pattern.exec(String(source || ''))) !== null) {
+    if (!names.includes(match[1])) {
+      names.push(match[1]);
+    }
+  }
+  return names.sort();
+}
+
+function actionCatalogEntryNames(entry) {
+  return [entry && entry.id, entry && entry.name]
+    .filter(Boolean)
+    .map(String);
+}
+
+function syncDesignerActionCatalog(actions) {
+  const source = actions && actions.module && actions.module.source || '';
+  const list = Array.isArray(actions.list) ? actions.list.slice() : [];
+  const existingNames = new Set();
+  list.forEach(function (entry) {
+    actionCatalogEntryNames(entry).forEach(function (name) {
+      existingNames.add(name);
+    });
+  });
+  extractExportedActionFunctionNames(source).forEach(function (name) {
+    if (!existingNames.has(name)) {
+      list.push({ id: name, title: name });
+      existingNames.add(name);
+    }
+  });
+  actions.list = list;
+  return actions.list;
+}
+
+function findFieldById(value, fieldId) {
+  if (!value || !fieldId) {return null;}
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = findFieldById(item, fieldId);
+      if (found) {return found;}
+    }
+    return null;
+  }
+  if (typeof value !== 'object') {return null;}
+  if (String(value.fieldId || '') === String(fieldId) ||
+    value.props && String(value.props.fieldId || '') === String(fieldId)) {
+    return value;
+  }
+  for (const child of Object.values(value)) {
+    const found = findFieldById(child, fieldId);
+    if (found) {return found;}
+  }
+  return null;
+}
+
+function inspectActionBinding(schema, expectation) {
+  const fieldId = String(expectation.fieldId || '');
+  const event = String(expectation.event || 'onChange');
+  const actionName = String(expectation.actionName || '');
+  const relatedEventId = String(expectation.relatedEventId || '');
+  const field = findFieldById(schema && schema.pages || schema, fieldId);
+  const eventValue = field && field.props && field.props[event];
+  const actualActionName = actionRefName(eventValue);
+  const designerBindingFound = isDesignerEventBinding(eventValue, actionName);
+  const actions = schema && schema.actions || {};
+  const entries = Array.isArray(actions.list) ? actions.list : [];
+  const source = actions.module && typeof actions.module.source === 'string'
+    ? actions.module.source
+    : '';
+  const functions = extractExportedActionFunctionNames(source);
+  const entry = entries.find(function (item) {
+    const itemNames = actionCatalogEntryNames(item);
+    const itemEventId = String(item && item.relatedEventId || '');
+    return itemNames.includes(actionName) && (!relatedEventId || !itemEventId || itemEventId === relatedEventId);
+  });
+  const bindingFound = actualActionName === actionName && designerBindingFound;
+  const actionEntryFound = !!entry;
+  const actionFunctionFound = functions.includes(actionName);
+  const mismatches = [];
+  if (!field) {mismatches.push('FIELD_NOT_FOUND');}
+  if (!actualActionName) {mismatches.push('FIELD_EVENT_BINDING_MISSING');}
+  else if (!designerBindingFound) {mismatches.push('DESIGNER_EVENT_BINDING_MISSING');}
+  if (!actionEntryFound) {mismatches.push('ACTION_ENTRY_MISSING');}
+  if (!actionFunctionFound) {mismatches.push('ACTION_FUNCTION_MISSING');}
+
+  return {
+    fieldId,
+    event,
+    actionName,
+    relatedEventId,
+    actualActionName,
+    bindingFound,
+    designerBindingFound,
+    actionEntryFound,
+    actionFunctionFound,
+    verified: mismatches.length === 0,
+    mismatches,
+  };
+}
+
+function inspectActionBindings(schema, expectations) {
+  const bindings = (expectations || []).map(function (expectation) {
+    return inspectActionBinding(schema, expectation);
+  });
+  return {
+    verified: bindings.every(function (binding) {return binding.verified;}),
+    bindings,
+  };
+}
+
+module.exports = {
+  actionRefs,
+  actionRefName,
+  buildDesignerEventBinding,
+  extractExportedActionFunctionNames,
+  findFieldById,
+  inspectActionBinding,
+  inspectActionBindings,
+  isDesignerEventBinding,
+  syncDesignerActionCatalog,
+};

package/lib/app/schema-semantic-analysis.js

@@ -57,7 +57,9 @@ function extractFunctionNames(source) {
   const names = [];
   const patterns = [
     /export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/g,
+    /export\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/g,
     /exports\.([A-Za-z_$][\w$]*)\s*=\s*/g,
+    /module\.exports\.([A-Za-z_$][\w$]*)\s*=\s*/g,
   ];
   for (const pattern of patterns) {
     let match;
@@ -94,13 +96,31 @@ function extractFieldMutations(source) {
   });
 }
 
-function bindingFromValue(value, path) {
-  if (!value || typeof value !== 'object' || value.type !== 'actionRef') {return null;}
-  return {
-    event: path[path.length - 1] || '',
+function bindingsFromValue(value, path, fieldId, requiresDesignerBinding) {
+  if (!value || typeof value !== 'object') {return [];}
+  const event = path[path.length - 1] || '';
+  if (value.type === 'JSExpression' && Array.isArray(value.events)) {
+    const expression = String(value.value || '');
+    return value.events.filter(item => item && item.type === 'actionRef').map(item => {
+      const actionName = item.name || item.id || '';
+      return {
+        event,
+        actionName,
+        fieldId: fieldId || '',
+        bindingFormat: 'designerEventFlow',
+        designerBindingFound: expression.includes('legaoBuiltin.execEventFlow') &&
+          expression.includes('this.' + actionName),
+      };
+    });
+  }
+  if (value.type !== 'actionRef') {return [];}
+  return [{
+    event,
     actionName: value.name || value.id || '',
-    fieldId: path.find(part => typeof part === 'string' && /Field_/.test(part)) || '',
-  };
+    fieldId: fieldId || '',
+    bindingFormat: 'legacyActionRef',
+    designerBindingFound: !requiresDesignerBinding,
+  }];
 }
 
 function buildSemanticAnalysis(appType, formUuid, schemaResult, fieldSummary = []) {
@@ -112,18 +132,30 @@ function buildSemanticAnalysis(appType, formUuid, schemaResult, fieldSummary = [
   const bindings = [];
   let associationRuleCount = 0;
 
-  function visit(value, path = []) {
+  function visit(value, path = [], parentFieldId = '', parentRequiresDesignerBinding = false) {
     if (!value) {return;}
     if (Array.isArray(value)) {
-      value.forEach((item, index) => visit(item, path.concat(index)));
+      value.forEach((item, index) => visit(
+        item,
+        path.concat(index),
+        parentFieldId,
+        parentRequiresDesignerBinding
+      ));
       return;
     }
     if (typeof value !== 'object') {return;}
 
-    const binding = bindingFromValue(value, path);
-    if (binding) {bindings.push(binding);}
-
     const props = value.props || {};
+    const fieldId = props.fieldId ? String(props.fieldId) : parentFieldId;
+    const requiresDesignerBinding = props.fieldId && /Field$/.test(String(value.componentName || ''))
+      ? true
+      : parentRequiresDesignerBinding;
+    const valueBindings = bindingsFromValue(value, path, fieldId, requiresDesignerBinding);
+    if (valueBindings.length > 0) {
+      bindings.push(...valueBindings);
+      return;
+    }
+
     if (Array.isArray(props.associationRules)) {
       associationRuleCount += props.associationRules.length;
     }
@@ -170,7 +202,7 @@ function buildSemanticAnalysis(appType, formUuid, schemaResult, fieldSummary = [
 
     Object.keys(value).forEach((key) => {
       if (key !== 'source' && key !== 'compiled') {
-        visit(value[key], path.concat(key));
+        visit(value[key], path.concat(key), fieldId, requiresDesignerBinding);
       }
     });
   }
@@ -186,6 +218,16 @@ function buildSemanticAnalysis(appType, formUuid, schemaResult, fieldSummary = [
     type: item.type || '',
     relatedEventId: item.relatedEventId || '',
   }));
+  const actionFunctions = extractFunctionNames(source);
+  const verifiedBindings = bindings.map(binding => {
+    const actionFunctionFound = actionFunctions.includes(binding.actionName);
+    const actionEntryFound = actionEntries.some(entry => entry.id === binding.actionName || entry.name === binding.actionName);
+    return Object.assign({}, binding, {
+      actionFunctionFound,
+      actionEntryFound,
+      verified: actionFunctionFound && actionEntryFound && binding.designerBindingFound,
+    });
+  });
   const mutationFields = unique(extractFieldMutations(source).map(item => item.fieldId));
 
   return {
@@ -202,9 +244,9 @@ function buildSemanticAnalysis(appType, formUuid, schemaResult, fieldSummary = [
       actions: {
         sourceBytes: Buffer.byteLength(source, 'utf8'),
         compiledBytes: Buffer.byteLength(compiled, 'utf8'),
-        functions: extractFunctionNames(source),
+        functions: actionFunctions,
         entries: actionEntries,
-        bindings,
+        bindings: verifiedBindings,
         urlParams: extractUrlParams(source),
         fieldMutations: extractFieldMutations(source),
         referencedMutationFields: mutationFields,

package/lib/core/locales/en.js

@@ -803,6 +803,12 @@ Examples:
     patch_must_not_be_empty: 'Patch array must not be empty',
     patch_invalid_shape: 'Patch must be an array, {operations: []}, or a single operation object',
     patch_parse_failed: 'Failed to parse patch JSON: ',
+    action_event_conflict: 'Field "{0}" event {1} is already bound to action "{2}"; silent replacement is blocked. Set replaceExisting=true only after confirming replacement.',
+    action_source_export_missing: 'The action source does not export the requested function "{0}".',
+    action_source_missing: 'Action function "{0}" was not found. Provide source/sourceFile or define it in the action module first.',
+    action_binding_incomplete: 'The form action function, action registry entry, and field event binding are incomplete. The Schema was not saved.',
+    action_readback_failed: 'The form action save was accepted, but readback failed: {0}',
+    action_readback_mismatch: 'The form action save was accepted, but the remote function, action registry entry, or field event binding did not match.',
     rule_file_not_found: 'Rule file not found: ',
     rule_array_empty: 'Rule array must not be empty',
     rules_array_empty: 'The rules array must not be empty',

package/lib/core/locales/zh.js

@@ -775,6 +775,12 @@ openyida - 宜搭命令行工具
     patch_must_not_be_empty: '补丁数组不能为空',
     patch_invalid_shape: '补丁必须是数组、{operations: []} 或单个操作对象',
     patch_parse_failed: '补丁 JSON 解析失败: ',
+    action_event_conflict: '字段“{0}”的 {1} 已绑定动作“{2}”；默认禁止静默覆盖。确认替换时显式设置 replaceExisting=true。',
+    action_source_export_missing: '动作源码未导出指定函数“{0}”。',
+    action_source_missing: '未找到动作函数“{0}”；请提供 source/sourceFile，或先在动作模块中定义该函数。',
+    action_binding_incomplete: '表单动作函数、动作注册和字段事件绑定不完整，Schema 未保存。',
+    action_readback_failed: '表单动作保存已被接受，但回读失败：{0}',
+    action_readback_mismatch: '表单动作保存已被接受，但远端回读的函数、动作注册或字段事件绑定不一致。',
     rule_file_not_found: '规则文件不存在: ',
     rule_array_empty: '规则数组不能为空',
     rules_array_empty: 'rules 数组不能为空',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openyida",
-  "version": "2026.8.31",
+  "version": "2026.9.1",
   "description": "OpenYida CLI - 宜搭低代码 AI 开发工具（安装即用，零配置）",
   "bin": {
     "openyida": "bin/yida.js",

package/yida-skills/references/yida-api.md

@@ -4,6 +4,16 @@
 
 所有接口返回 Promise，统一使用 `.then()` 和 `.catch()` 处理结果和异常。
 
+## 页面 JS 与动作面板基础契约
+
+- 只有顶层 `export function actionName(...) {}` 会出现在动作面板，供组件事件和生命周期绑定。
+- 一个导出动作调用另一个导出动作时使用 `this.actionName(...)`；未导出的纯 helper 可直接调用，但不能依赖宜搭注入的 `this`。
+- 表单字段通过 `this.$('fieldId')` 访问，读值用 `getValue()`，赋值用 `setValue(value, options)`；需要触发目标字段 `onChange` 时显式设置 `options.triggerChange`。
+- 组件事件参数以对应组件 API 为准。下拉单选 `onChange` 直接传入动作参数 `value`，不要从 `event` 取值。该参数可能是原始值、`{ value, actionType }`，开启 `useDetailValue=true` 后也可能是 `{ value: { label, value }, actionType }`。兼容写法：先用 `value && value.value !== undefined ? value.value : value` 取得动作值，再以相同方式取得选项明细值。宜搭动作面板不支持空值合并运算符，使用 `?:`。仅写函数源码不算完成，必须在设计器中绑定事件；OpenYida 写入后也必须回读确认绑定仍存在。
+- 不同组件不能统一 `String(value)`：文本、数字、评分、单选和单日期解包后是标量；多选、复选、部门、国家、附件和图片是数组；日期区间是 `{ start, end }`；成员单选交互可能是对象，但初始化可能是数组。只有 `SelectField useDetailValue` 需要继续取选项对象的 `.value`，其他对象或数组必须保留结构。
+
+官方参考：[动作面板](https://alidocs.dingtalk.com/i/nodes/1zknDm0WRz0NZeXQux7OKZXmWBQEx5rG)、[`this` 调用语义](https://alidocs.dingtalk.com/i/nodes/Exel2BLV5gOAdXr1umO9QPNr8gk9rpMq)、[生命周期](https://alidocs.dingtalk.com/i/nodes/pGBa2Lm8aeP35vxdtEKBlz4D8gN7R35y)、[SelectField](https://developers.aliwork.com/docs/components/form/selectField)、[宜搭 JS API](https://developers.aliwork.com/docs/api/yidaAPI)。
+
 ---
 
 ## 目录

package/yida-skills/skills/yida-app/SKILL.md

@@ -36,6 +36,7 @@ description: 宜搭完整应用开发编排技能。对普通 OpenYida 应用做
 5. **真实 ID 和真实数据**：不编造 `appType`、`formUuid`、`fieldId`、`processCode`、`reportId`。完整应用默认给核心普通表单写入 1-3 条业务化 seed records 并 query 抽查；不适合造数时说明原因和空态方案。
 6. **自定义页面开发技能固定**：完整应用页面源码按 Step 7 执行。
 7. **删除必须确认**：用户要求删除应用时，先展示应用名称、应用 ID 和影响范围，等待明确“确认删除”后才能执行。
+8. **列表页选择**：默认使用普通表单的数据管理页；用户明确要求自定义列表页时才创建 display 页面。
 
 ## 关键决策树
 
@@ -48,7 +49,7 @@ description: 宜搭完整应用开发编排技能。对普通 OpenYida 应用做
 
 - 默认页面源码不得使用 `this.dataSourceMap.*`，除非本轮已经创建并绑定对应设计器数据源。
 - 真实表单数据默认通过页面数据桥或 `window.__OPENYIDA_YIDA_API__.searchFormDatas(params)` 读取；不要用前端 seedRows 冒充真实表单数据。
-- 完整应用的列表、看板、详情页优先读取真实表单数据，`page-spec.json` 写 `dataBinding.mode=form`、真实 `appType/formUuid/fieldId` 和字段映射。
+- 用户明确要求的自定义列表、看板和详情页优先读取真实表单数据；`page-spec.json` 写 `dataBinding.mode=form`、真实 `appType/formUuid/fieldId` 和字段映射。表单数据管理页不另生成页面源码。
 - 完整应用默认先写入 1-3 条业务化 seed records 并 query 抽查；没写入成功时，页面展示空态、表单入口、刷新或登记按钮，并在 final 说明原因。
 - 若页面确实依赖 `this.dataSourceMap.*`，必须执行 `use_skill("yida-data-source-connectors")` 创建/绑定数据源，并在发布后确认页面 Schema 中存在对应数据源；发布输出出现 `No custom page data sources to preserve` 时，本次发布不能视为完成。
 

package/yida-skills/skills/yida-app/workflow/step-4-forms-processes.md

@@ -20,7 +20,7 @@
 7. 页面、数据、流程或公式确需多字段映射时，对每个目标表单最多一次性执行 `openyida get-schema <appType> <formUuid> --field-map-json`，合并写回 `.cache/<项目名>-schema.json`。
 8. PRD 包含审批、流程、申请、审核、工单等流程对象时，执行 `use_skill("yida-create-process", "创建带审批流程表单")`。
 9. 已有流程表单或 `processCode` 时，执行 `use_skill("yida-process-rule", "更新已有流程规则")`。
-10. 分析、复刻或迁移已有表单时，执行 `use_skill("yida-get-schema", "读取字段与行为语义")`，对每个核心表单读取一次 `--analysis-json`；把字段结构与 `actions/fieldBehaviors/associationRuleCount` 分开规划，存在业务动作时使用 `yida-create-form-page` 的 `actions-module`、`bind-field-action`、`bind-datasource` 等高级 patch 能力。
+10. 分析、复刻或迁移已有表单时，执行 `use_skill("yida-get-schema", "读取字段与行为语义")`，对每个核心表单读取一次 `--analysis-json`；把字段结构与 `actions/fieldBehaviors/associationRuleCount` 分开规划，字段事件动作使用 `yida-create-form-page` 的原子 `field-action`，数据源使用 `bind-datasource`。
 11. PRD 明确包含原生报表时，执行 `use_skill("yida-report", "按业务统计语义创建原生报表")`；地域分布、日历统计分别使用已支持的 `map`、`calendarHeatmap`，不得无声明退化成柱/饼图。
 12. PRD 明确包含集成自动化时，执行 `use_skill("yida-integration", "按业务动作创建自动化")`；已有应用先用全类型 `integration list --json` 盘点，创建时区分通知、数据新增/更新、审批完成、定时和手动触发。CLI 不支持的触发类型输出 capability gap，不得用通知替代。
 

package/yida-skills/skills/yida-create-form-page/SKILL.md

@@ -48,7 +48,7 @@ description: 表单页面创建与更新，默认加载 yida-form-detail 作为
 |------|------|
 | 创建新表单 / 设计字段结构 | 本技能 `create` 模式 |
 | 增删改字段结构 | 本技能 `update` 模式 |
-| 配置 OpenYida 尚未封装的平台字段属性/动作 | 本技能 `patch` 模式，先读 [advanced-form-modes.md](references/advanced-form-modes.md) |
+| 配置 OpenYida 尚未封装的平台字段属性/动作 | 本技能 `patch` 模式；字段事件动作使用原子 `field-action`，先读 [advanced-form-modes.md](references/advanced-form-modes.md) |
 | 字段显示隐藏、只读、自动赋值 | 本技能 `rule` 模式，先读 [advanced-form-modes.md](references/advanced-form-modes.md) |
 | 选项字段远程搜索数据源 | 本技能 `bind-datasource` 模式，先读 [advanced-form-modes.md](references/advanced-form-modes.md) |
 | 表单数据记录增删改查 | `yida-data-management` |
@@ -185,7 +185,7 @@ openyida create-form rule <appType> <formUuid> <rulesJsonOrFile>
 
 | 模式 | 命令 | 何时使用 |
 |------|------|------|
-| `patch` | `openyida create-form patch <appType> <formUuid> <patchJsonOrFile>` | 受控修改底层 Schema、字段 props、动作模块、自定义校验 |
+| `patch` | `openyida create-form patch <appType> <formUuid> <patchJsonOrFile>` | 受控修改底层 Schema；字段事件动作必须用 `field-action` 并确认 `designerBindingFound: true`、`readbackVerified: true` |
 | `rule` | `openyida create-form rule <appType> <formUuid> <rulesJsonOrFile>` | 字段显示隐藏、只读、自动赋值、onChange 带出 |
 | `validation` | `openyida create-form validation <appType> <formUuid> <validationsJsonOrFile>` | 字段校验规则，优先用内置校验，复杂场景再用 customValidate |
 | `bind-datasource` | `openyida create-form bind-datasource <appType> <formUuid> <fieldLabelOrId> <dataSourceJsonOrFile>` | 选项字段绑定远程搜索数据源；成功输出 `resolved` |

package/yida-skills/skills/yida-create-form-page/references/advanced-form-modes.md

@@ -19,8 +19,41 @@ openyida create-form patch <appType> <formUuid> <patchJsonOrFile>
 | `merge` | 对指定 JSON Pointer 路径做对象深合并 |
 | `actions-module` | 写入页面动作模块 `source` / `compiled`，`source` 会自动编译 |
 | `bind-field-action` | 给字段事件（如 `onChange`）绑定动作引用 |
+| `field-action` | 原子写入动作函数、注册动作并绑定字段事件；字段自定义事件默认使用此操作 |
 | `bind-datasource` | 给选项类字段绑定远程搜索数据源（高阶入口优先用 bind-datasource 模式） |
 
+字段事件动作不得只写 `actions-module`。默认使用 `field-action`，并以返回的 `designerBindingFound: true` 和 `readbackVerified: true` 为完成条件：
+
+```json
+[
+  {
+    "action": "field-action",
+    "field": "状态",
+    "event": "onChange",
+    "name": "handleStatusChange",
+    "source": "export function handleStatusChange(value) {\n  var actionValue = value && value.value !== undefined ? value.value : value;\n  var selectedValue = actionValue && actionValue.value !== undefined ? actionValue.value : actionValue;\n  if (selectedValue === 'A') {\n    this.$('textField_result').setValue('已执行');\n  }\n}"
+  }
+]
+```
+
+入口动作必须是顶层 `export function`，否则不会出现在宜搭动作面板。导出动作之间通过 `this.xxx()` 调用；未导出的纯 helper 可直接调用，但不能使用宜搭页面上下文。下拉单选 `onChange` 会把动作参数作为 `value` 传入，不要从 `event` 取值。该参数可能是原始值、`{ value, actionType }`，开启 `useDetailValue=true` 后也可能是 `{ value: { label, value }, actionType }`；先取动作值，再取选项明细值即可兼容三种形态。宜搭动作面板不支持空值合并运算符，使用 `?:`。
+
+不同组件不能统一 `String(value)`。先用 `value && value.value !== undefined ? value.value : value` 去掉动作参数外层，再按组件处理：
+
+| 组件 | 实际动作值 |
+|------|------------|
+| TextField / NumberField / RateField / RadioField | 字符串或数字 |
+| DateField | 毫秒时间戳 |
+| MultiSelectField / CheckboxField | 选中值数组 |
+| DepartmentSelectField / CountrySelectField | `{ text, value }` 数组 |
+| AttachmentField / ImageField | 文件对象数组 |
+| CascadeDateField | `{ start, end }` |
+| EmployeeField | 单选交互可能是成员对象，初始化可能是成员数组，先归一化为数组 |
+
+`SelectField` 开启 `useDetailValue` 后再取一次 `.value`；其他对象或数组必须保留结构，不能盲目取第二层。
+
+如果目标事件已有其他动作，命令默认停止，避免静默覆盖；只有确认替换时才设置 `replaceExisting: true`。`actions-module` + `bind-field-action` 仅保留给低阶迁移场景，仍会执行设计器原生绑定校验和保存后回读。运行时发生联动但设计器仍显示“新建动作”属于失败，不能作为验收通过。
+
 隐藏但仍提交字段：
 
 ```json
@@ -66,7 +99,7 @@ openyida create-form patch <appType> <formUuid> <patchJsonOrFile>
 - 函数返回 `true` 表示校验通过，`false` 表示校验失败
 - 子表内字段通过 `this.item.values` 获取同行其他字段的值
 
-如必须桥接 JS 面板函数，先用 `actions-module` 写入函数，再在字段自定义函数里通过 `this.xxx()` 调用。
+如必须桥接 JS 面板函数，使用 `field-action` 原子写入并绑定入口函数，再在字段自定义函数里通过 `this.xxx()` 调用。
 
 ## rule 模式（字段联动与自动赋值）
 
@@ -122,7 +155,7 @@ JS 表达式计算目标值，表达式可使用 `value`（触发字段值）和
 ]
 ```
 
-rule 模式会自动生成宜搭动作代码，绑定触发字段的 `onChange`，并在页面加载/表单数据初始化后执行一次规则。若字段已有 `onChange` 动作，OpenYida 会先调用原动作，再执行生成的规则。
+rule 模式会自动生成宜搭动作代码，绑定触发字段的 `onChange`，并在页面加载/表单数据初始化后执行一次规则。每次调用传入的规则数组视为当前 OpenYida 联动规则全集；重写时会清理不再使用的生成绑定。若字段已有 `onChange` 动作，OpenYida 会保留并先调用原动作，再执行生成的规则。
 
 ## bind-datasource 模式（选项字段远程搜索数据源）
 

package/yida-skills/skills/yida-design/SKILL.md

@@ -48,7 +48,7 @@ description: >
 
 1. **平台能力优先**：数据录入、提交、编辑、审批、权限、字段校验走宜搭表单/流程；自定义页负责展示数据、呈现分析结果、放置业务入口、打开详情页，并串联表单、流程、报表和导航入口。
 2. **需求分析归本技能**：完整应用设计先写清应用基本信息、用户角色、核心任务、业务对象、数据结构、页面与表单/流程资源、业务逻辑、交互状态和验收标准。
-3. **应用资源蓝图先行**：完整应用设计先列清资源蓝图，包括主页面/工作台/看板/列表/详情等 display 自定义页面，以及普通表单、流程表单和报表；表单字段写业务语义、字段类型、必填、默认值、关联关系和分组，运行后 ID 由实现阶段记录。
+3. **应用资源蓝图先行**：资源蓝图列出必要的 display 页面、表单、流程和报表。普通表单的数据管理页默认作为列表；用户明确要求时才规划自定义列表页。表单写业务语义、类型、必填、默认值、关系和分组；运行 ID 由实现阶段记录。
 4. **顺序分开写清**：PRD 同时写资源创建顺序、页面实现交付顺序和导航顺序。资源创建顺序服务依赖关系，表单/流程在自定义页面之前；页面实现交付顺序服务开发验收；导航顺序服务用户入口展示。
 5. **美感提升保持功能契约**：页面美化、视觉升级和页面重构默认只调整颜色、布局、密度、间距、视觉层级、素材和图标表达；现有数据源、字段映射、按钮动作、筛选逻辑、提交 URL、权限和业务状态保持原样。
 6. **默认保留平台应用导航**：普通自定义页、页面内 tab、分段、筛选和快捷入口都不触发 `yida-nav-shell`。只有自定义页要做顶部导航、侧边导航、导航壳、自绘应用级导航，或用户明确隐藏应用导航时，才写 `appBlueprint.hideAppNav: 'y'` 并交给 `yida-nav-shell`。用户只说全屏、无导航或 `isRenderNav=false` 时，只写页面级隐藏配置。

package/yida-skills/skills/yida-design/workflow/output-prd.md

@@ -121,10 +121,12 @@
 | 资源 | 类型 | 用途 | 关键字段 / 功能 | 创建策略 |
 | --- | --- | --- | --- | --- |
 | <主页面> | display-page / main | <入口和概览> | <contentBlocks：推荐 8-10 个区块以上，如标题上下文、筛选、摘要、主操作、待办、最近记录、动态、提醒、右侧上下文、空态行动等；不作为硬门槛> | <复用 / 创建> |
-| <业务表单> | normal-form | <数据录入和管理> | <核心字段> | <复用 / 创建 / 更新> |
+| <业务表单> | normal-form | <数据录入和列表管理> | <核心字段> | <复用 / 创建 / 更新> |
 | <审批表单> | process-form | <流程闭环> | <节点和条件> | <复用 / 创建 / 更新> |
 | <报表> | report | <汇总分析> | <指标口径> | <复用 / 创建 / 更新> |
 
+默认不创建自定义列表页；用户明确要求时才新增 `display-page / list`。
+
 ## 8. 资源创建顺序
 
 资源创建顺序服务于依赖关系；表单/流程在自定义页面之前创建，便于页面消费表单 URL、字段语义和数据来源。
@@ -146,7 +148,7 @@
 | 顺序 | 页面 | 实现重点 | 依赖资源 | 验收点 |
 | --- | --- | --- | --- | --- |
 | 1 | <主页面 / 工作台 / 官网首页> | <首屏、核心入口、主题风格> | <表单入口 / 空态 / 指标口径> | <打开后能完成核心判断> |
-| 2 | <核心列表 / 管理页> | <筛选、表格、详情抽屉、主操作> | <核心业务表单> | <能查看或进入新增/详情> |
+| 2 | <数据管理入口> | <默认使用表单数据管理页；用户要求时实现自定义列表> | <核心业务表单> | <可新增或查看详情> |
 | 3 | <详情 / 看板 / 大屏> | <对象叙事、图表、状态、洞察> | <表单数据 / 报表> | <能解释业务状态> |
 | 4 | <辅助页面> | <配置、说明、低频入口> | <相关表单或链接> | <不阻断主链路> |
 
@@ -158,7 +160,7 @@
 | --- | --- | --- | --- |
 | 门户 / 首页 | <主页面 / 工作台 / 官网首页> | <平台导航 / 顶部导航 / 侧边导航 / 单页入口> | 第一入口放最前 |
 | 业务办理 | <流程表单 / 新增入口 / 待办相关页面> | <平台导航或页面内快捷入口> | 高频动作靠前 |
-| 数据管理 | <普通表单 / 列表页 / 详情页> | <平台导航分组> | 数据录入、查询和维护集中 |
+| 数据管理 | <表单数据管理页 / 用户要求的自定义列表页 / 详情页> | <平台导航分组> | 数据录入、查询和维护集中 |
 | 经营分析 | <看板 / 报表 / 大屏> | <平台导航 / 大屏全屏入口 / 页面级隐藏导航 isRenderNav=false> | 管理者查看，放在业务操作之后或独立分组 |
 | 系统配置 | <配置表 / 字典表 / 权限说明> | <平台导航靠后分组> | 低频维护靠后 |
 
@@ -170,7 +172,7 @@
 | 数据录入 | <表单能提交，提交后页面能刷新或回到正确入口> |
 | 表单主题和详情页样式 | <普通表单和流程表单已注入 `style#yida-global-theme`，formDetail 详情页已注入 `style#yida-form-detail-style`，与应用和自定义页面主题色一致> |
 | 初始示例数据 | <完整应用默认已为核心普通表单写入 1-3 条业务化示例记录并 query 抽查；跳过时说明原因> |
-| 数据查看 | <列表 / 看板 / 详情能看到真实表单数据或清晰空态> |
+| 数据查看 | <默认使用表单数据管理页；自定义列表 / 看板 / 详情显示真实数据或空态> |
 | 权限 / 流程 | <权限规则或流程节点生效> |
 | 视觉一致性 | <主题色、布局密度、状态、图标和当前业务一致> |
 | 导航可用 | <导航顺序符合 PRD，主入口靠前，配置/低频资源靠后> |

package/yida-skills/skills/yida-design/workflow/step-3-information-architecture.md

@@ -18,7 +18,8 @@
 | 页面 | resourceType | scene | 用途 | 实现链路 |
 | --- | --- | --- | --- | --- |
 | 主页 / 首页 / 工作台 | `display-page` | `workbench/dashboard/landing` | 应用第一入口、指标概览、快捷入口 | 自定义页面 |
-| 管理列表页 | `display-page` | `list` | 查询、筛选、批量操作、详情入口 | 自定义页面 |
+| 表单数据管理页 | `normal-form` | `native-list` | 查询、筛选、查看、编辑和维护 | 宜搭表单数据管理页（默认） |
+| 自定义列表页 | `display-page` | `list` | 用户明确要求自定义列表页 | 自定义页面 |
 | 详情页 | `display-page` | `detail` | 单对象信息总览、时间线、关联对象 | 自定义页面 |
 | 数据大屏 / 看板 | `display-page` 或报表 | `screen/dashboard` | 指标监控、经营分析、投屏展示 | Canvas / Recharts / 报表 |
 
@@ -31,6 +32,8 @@
 
 资源清单使用业务语义和资源类型；`appType/corpId/baseUrl` 写入 PRD 的应用配置，`formUuid`、`fieldId`、`processCode` 等细节 ID 由实现阶段写入 `.cache/<项目名>-schema.json`。
 
+同一业务对象默认使用普通表单的数据管理页；用户明确要求时才增加自定义列表页。
+
 ## 给页面标场景
 
 页面 `scene` 只作为分类标签和实现提示，不作为固定页面样式。页面结构必须来自当前业务目标、用户任务、资源关系和后续 `design.md`。
@@ -40,7 +43,7 @@
 | workbench | 进入应用后处理任务、看状态、做高频动作 | 当前业务 `contentBlocks` + `design.md.visualScaffold` |
 | dashboard | 经营分析、指标判断、趋势和排行 | 指标口径 + 图表目的 + `design.md.visualScaffold` |
 | screen | 投屏、监控、态势感知 | 实时信息层级 + 大屏展示目标 + `design.md.visualScaffold` |
-| list | 查询、筛选、批量操作、详情入口 | 数据字段、筛选条件、操作路径 + `design.md.visualScaffold` |
+| list | 用户明确要求的自定义列表 | 数据字段、筛选、操作路径 + `design.md.visualScaffold` |
 | detail | 单对象总览、时间线、关联对象 | 对象信息架构 + 关联关系 + `design.md.visualScaffold` |
 | landing | 对外介绍、品牌表达、价值转化 | 价值路径、素材清单、CTA + `design.md.visualScaffold` |
 | split-pane | 左列表右详情、处理台 | 主从关系、处理路径 + `design.md.visualScaffold` |