openyida 2026.10.12-beta.2 → 2026.10.13

package/lib/app/create-form.js

@@ -862,6 +862,16 @@ function buildFieldComponent(field) {
       props.mode = 'multiple';
     }
 
+    const explicitDefault = field.value ?? field.defaultValue ?? field.props?.value
+      ?? field.props?.complexValue?.value;
+    const checkedValues = dataSource.filter(item => item.defaultChecked).map(item => item.value);
+    const selected = explicitDefault !== undefined
+      ? explicitDefault
+      : ((componentName === 'CheckboxField' || componentName === 'MultiSelectField')
+        ? (checkedValues.length ? checkedValues : '') : (checkedValues[0] ?? ''));
+    props.value = selected;
+    props.complexValue.value = selected;
+
     if (field.remoteDataSource || field.searchDataSource || field.dataSourceConfig || field.dataSourceUrl || field.searchConfig) {
       applySelectDataSourceConfig(props, field.remoteDataSource || field.searchDataSource || field.dataSourceConfig || {
         url: field.dataSourceUrl,
@@ -4809,6 +4819,9 @@ function buildCreateFormPostCreateFailurePayload(context) {
     errorCode: errorObject && errorObject.code ? errorObject.code : (context.errorCode || 'CREATE_FORM_POST_CREATE_FAILED'),
     retryAdvice: t('create_form.create_post_failure_retry_advice', context.appType, context.formTitle),
   };
+  for (const key of ['remoteSaveState', 'missingFieldCount', 'diagnostics']) {
+    if (errorObject?.details?.[key] !== undefined) { payload[key] = errorObject.details[key]; }
+  }
   if (context.fieldCount !== undefined) {
     payload.fieldCount = context.fieldCount;
   }
@@ -5057,8 +5070,12 @@ async function mainCreate(parsedArgs, authRef) {
       formUuid,
       fieldCount,
     });
+    postCreateStage = 'verifySavedSchema';
+    await verifyCreatedFormSchema(authRef, appType, formUuid, fields);
     postCreateStage = 'updateFormNavigationIcon';
     await updateCreatedFormNavigationIcon(authRef, appType, formUuid, formIcon);
+    postCreateStage = 'verifyFinalSchema';
+    await verifyCreatedFormSchema(authRef, appType, formUuid, fields);
   } catch (err) {
     emitCreateFormPostCreateFailure({
       appType,
@@ -5164,7 +5181,9 @@ async function createFormForLegacyProcessQuiet(context, input) {
     applySmartValidations(schema, createValidationRules);
   }
   const saveResult = await saveFormSchema(authRef, appType, formUuid, schema, serverRevision, 4);
+  await verifyCreatedFormSchema(authRef, appType, formUuid, fields);
   const navIconResult = await updateCreatedFormNavigationIcon(authRef, appType, formUuid, formIcon);
+  await verifyCreatedFormSchema(authRef, appType, formUuid, fields);
   const { appUrl, formUrl } = buildFormDeliveryUrls(authRef.baseUrl, appType, formUuid);
   return {
     success: true,
@@ -6154,13 +6173,34 @@ async function readResumeSchema(authRef, appType, formUuid) {
   return { schemaResult, schema, version: extractSchemaServerRevision(schemaResult) };
 }
 
+async function verifyCreatedFormSchema(authRef, appType, formUuid, fields) {
+  const readback = await readResumeSchema(authRef, appType, formUuid);
+  const root = readback.schema.pages[0].componentsTree?.[0];
+  const container = root ? findFormContainer(root) : null;
+  const verified = buildResumeChanges(
+    collectResumeFieldEvidence(container?.children),
+    collectResumeDesiredFields(fields, { verifyNestedFields: true })
+  );
+  if (verified.missing.length || verified.conflicts.length) {
+    throwCreateFormError(t('create_form.create_readback_mismatch'),
+      'CREATE_FORM_CREATE_READBACK_MISMATCH', {
+        appType, formUuid, retryable: false,
+        remoteSaveState: verified.existing.length ? 'partial' : 'not_saved',
+        missingFieldCount: verified.missing.length, diagnostics: verified.conflicts,
+      });
+  }
+}
+
 function isRetryableResumeSaveServerFailure(errorObject) {
   const status = Number(errorObject?.details?.result?.__httpStatus);
+  const businessStatus = Number(errorObject?.details?.result?.errorCode
+    ?? errorObject?.details?.result?.code);
   return errorObject?.code === 'CREATE_FORM_SAVE_SCHEMA_FAILED' &&
-    Number.isInteger(status) && status >= 500 && status <= 599;
+    ((Number.isInteger(status) && status >= 500 && status <= 599)
+      || (Number.isInteger(businessStatus) && businessStatus >= 500 && businessStatus <= 599));
 }
 
-async function saveResumeSchemaWithSafeRetry(authRef, appType, formUuid, schema, version, fields) {
+async function saveResumeSchemaWithSafeRetry(authRef, appType, formUuid, schema, version, fields, attemptedFields = fields) {
   const save = (value, revision) => saveFormSchema(
     authRef, appType, formUuid, value, revision, 4, { deferFailureOutput: true }
   );
@@ -6170,6 +6210,7 @@ async function saveResumeSchemaWithSafeRetry(authRef, appType, formUuid, schema,
   } catch (originalError) {
     if (!isRetryableResumeSaveServerFailure(originalError)) { throw originalError; }
 
+    originalError.details = { ...originalError.details, remoteSaveState: 'unknown' };
     let readback;
     try { readback = await readResumeSchema(authRef, appType, formUuid); } catch (_) { throw originalError; }
     const root = readback.schema.pages[0].componentsTree && readback.schema.pages[0].componentsTree[0];
@@ -6182,6 +6223,12 @@ async function saveResumeSchemaWithSafeRetry(authRef, appType, formUuid, schema,
     );
     if (verified.conflicts.length > 0) { throw originalError; }
     if (verified.missing.length === 0) { return 'save_schema_recovered_by_readback'; }
+    const attempted = buildResumeChanges(evidence, collectResumeDesiredFields(attemptedFields, { verifyNestedFields: true }));
+    originalError.details.remoteSaveState = attempted.existing.length ? 'partial' : 'not_saved';
+    // A business 500 can be a duplicate-key INSERT. Readback provides facts,
+    // but never licenses another write on that ambiguous platform path.
+    const businessStatus = Number(originalError.details.result?.errorCode ?? originalError.details.result?.code);
+    if (businessStatus >= 500 && businessStatus <= 599) { throw originalError; }
     const retryPlan = buildResumeChanges(evidence, collectResumeDesiredFields(fields));
     if (retryPlan.conflicts.length > 0 || retryPlan.missing.length === 0) { throw originalError; }
     const applied = applyChangesToSchema(
@@ -6291,7 +6338,7 @@ async function mainResume(parsedArgs, authRef) {
     const updatedContainer = findFormContainer(firstRead.schema.pages[0].componentsTree[0]);
     fillSerialNumberFormulas(updatedContainer.children, corpId, appType, formUuid);
     const saveRecoveryStage = await saveResumeSchemaWithSafeRetry(
-      authRef, appType, formUuid, firstRead.schema, firstRead.version, fields
+      authRef, appType, formUuid, firstRead.schema, firstRead.version, fields, plan.missing
     );
     completedStages.push('add_missing_fields', 'save_schema');
     if (saveRecoveryStage) { completedStages.push(saveRecoveryStage); }

package/lib/app/custom-theme.js

@@ -2,8 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { resolveBearerAuthHeaders } = require('../core/utils');
-const { readManagedContext, managedError } = require('../agent/managed-context');
+const { getAccessToken } = require('../auth/token-auth');
 const { CliError } = require('../core/cli-error');
 const { t } = require('../core/i18n');
 const { findCssStructureIssue } = require('../core/css-structure');
@@ -261,13 +260,6 @@ function buildCustomThemeStyle(uploadResult) {
 }
 
 async function uploadCustomThemeFile(appType, filePath, authRef, options = {}) {
-  const managed = readManagedContext(process.env);
-  if (managed && appType !== managed.appType) {
-    throw managedError('MANAGED_APP_MISMATCH', 'managed_app_mismatch');
-  }
-  if (managed && new URL(authRef.baseUrl).origin !== new URL(managed.baseUrl).origin) {
-    throw managedError('MANAGED_OVERRIDE_FORBIDDEN', 'managed_override_forbidden');
-  }
   const file = readThemeCssFile(filePath);
   const fetchImpl = options.fetchImpl || globalThis.fetch;
   const FormDataImpl = options.FormDataImpl || globalThis.FormData;
@@ -276,7 +268,7 @@ async function uploadCustomThemeFile(appType, filePath, authRef, options = {}) {
     throw new Error('当前 Node.js 环境缺少 fetch/FormData/Blob，请使用 Node.js 18+');
   }
 
-  const auth = await resolveBearerAuthHeaders({ projectRoot: authRef && authRef.projectRoot });
+  const accessToken = await getAccessToken({ projectRoot: authRef && authRef.projectRoot });
   const endpoint = new URL('/query/app/customTheme/upload.json', authRef.baseUrl);
   if (authRef.csrfToken) {
     endpoint.searchParams.set('_csrf_token', authRef.csrfToken);
@@ -287,11 +279,9 @@ async function uploadCustomThemeFile(appType, filePath, authRef, options = {}) {
 
   const response = await fetchImpl(endpoint, {
     method: 'POST',
-    // Never forward a multipart request carrying credentials to another URL.
-    redirect: 'error',
     headers: {
       Accept: 'application/json, text/plain, */*',
-      ...auth.headers,
+      Authorization: `Bearer ${accessToken}`,
       Origin: authRef.baseUrl,
       Referer: `${authRef.baseUrl}/`,
       'x-requested-with': 'XMLHttpRequest',

package/lib/app/get-schema.js

@@ -78,12 +78,7 @@ function extractFieldSummary(schemaResult) {
         const complexDefault = props.complexValue && typeof props.complexValue === 'object'
           ? props.complexValue.value
           : undefined;
-        // Custom text defaults are rendered from props.value; complexValue may
-        // retain an obsolete empty value after a targeted field update.
-        const customText = ['TextField', 'TextareaField'].includes(node.componentName) && props.valueType === 'custom';
-        const defaultValue = firstPresent(customText
-          ? [props.value, complexDefault, props.defaultValue, props.default]
-          : [complexDefault, props.defaultValue, props.value, props.default]);
+        const defaultValue = firstPresent([complexDefault, props.defaultValue, props.value, props.default]);
         const validationRules = Array.isArray(props.validation) ? props.validation : [];
         const hasRequiredSignal = Object.prototype.hasOwnProperty.call(props, 'required')
           || validationRules.some(rule => rule && (rule.type === 'required' || rule.required === true));

package/lib/app/nav-group-create.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const { CliError } = require('../core/cli-error');
+const { resolveFormNavIcon } = require('./create-form/nav-icon');
+const { buildFormNavigationIconUpdatePayload } = require('./create-form/nav-icon-service');
+
+/** Create a group, then persist a semantic icon using the platform navigation protocol. */
+async function createGroupWithIcon(appType, name, flags, authRef, dependencies) {
+  const { fetchNavigationList, postNavAction, resolveNode, buildI18nTitle,
+    getNodeName, normalizeNavNode, rootNavUuid } = dependencies;
+  if (!name) {throw new Error('Group name is required');}
+  const selection = resolveFormNavIcon(flags.icon, name, []);
+  if (!selection.icon) {
+    throw new CliError('Invalid navigation icon. Use auto or a supported page navigation icon name.', {
+      code: 'NAV_GROUP_ICON_INVALID', details: { icon: flags.icon, retrySafe: true },
+    });
+  }
+  const list = await fetchNavigationList(appType, authRef);
+  const parent = resolveNode(list, flags.parent || rootNavUuid, { groupOnly: true });
+  if (parent.navUuid !== rootNavUuid && parent.parentNavUuid !== rootNavUuid) {
+    throw new Error('New groups can only be created at root or under a top-level group');
+  }
+
+  const beforeIds = new Set(list.map((node) => node.navUuid));
+  let created;
+  let stage = 'create';
+  try {
+    // Do not replay a creation on an uncertain response: it can duplicate the group.
+    await postNavAction(appType, 'save', {
+      parentNavUuid: parent.navUuid,
+      title: JSON.stringify(buildI18nTitle(name, flags.en)),
+    }, authRef, { oneShot: true });
+    stage = 'resolve';
+    const updatedList = await fetchNavigationList(appType, authRef);
+    const matches = updatedList.filter((node) => node.navType === 'NAV' &&
+      !beforeIds.has(node.navUuid) && getNodeName(node) === name &&
+      (node.parentNavUuid || rootNavUuid) === parent.navUuid);
+    if (matches.length !== 1) {
+      throw new Error('Created group could not be resolved uniquely.');
+    }
+    created = matches[0];
+    stage = 'icon';
+    await postNavAction(appType, 'update',
+      buildFormNavigationIconUpdatePayload(created, selection.icon), authRef, { oneShot: true });
+    stage = 'readback';
+    const observed = await fetchNavigationList(appType, authRef);
+    const verified = resolveNode(observed, created.navUuid, { groupOnly: true });
+    if (verified.icon !== selection.icon) {
+      throw new Error('Group navigation icon readback did not match the requested icon.');
+    }
+    return {
+      success: true, appType, action: 'create', group: normalizeNavNode(verified),
+      iconSource: selection.source, readbackVerified: true,
+    };
+  } catch (error) {
+    throw new CliError(error.message, {
+      code: 'NAV_GROUP_CREATE_INCOMPLETE',
+      details: {
+        appType, stage, name, parentNavUuid: parent.navUuid,
+        navUuid: created ? created.navUuid : null, expectedIcon: selection.icon,
+        partial: stage !== 'create', sideEffectState: created ? 'committed' : 'unknown',
+        retrySafe: false, readbackVerified: false, readbackAllowed: true,
+        nextStep: `openyida nav-group list ${appType} --flat`,
+      },
+    });
+  }
+}
+
+module.exports = { createGroupWithIcon };

package/lib/app/nav-group.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const querystring = require('querystring');
+const { createGroupWithIcon } = require('./nav-group-create');
 const {
   httpGet,
   httpPost,
@@ -44,6 +45,7 @@ function normalizeNavNode(node) {
     formUuid: node.formUuid || null,
     relateFormUuid: node.relateFormUuid || null,
     formType: node.formType || '',
+    icon: node.icon || null,
     hidden: node.hidden === 'y',
     mobileHidden: node.mobileHidden === 'y',
     listOrder: node.listOrder,
@@ -734,34 +736,12 @@ async function listGroups(appType, flags, authRef) {
   };
 }
 
+/** Reuse the page icon catalog and preserve the created navigation node when setting its icon. */
 async function createGroup(appType, name, flags, authRef) {
-  if (!name) {
-    throw new Error('Group name is required');
-  }
-
-  const list = await fetchNavigationList(appType, authRef);
-  const parent = resolveNode(list, flags.parent || ROOT_NAV_UUID, { groupOnly: true });
-  if (parent.navUuid !== ROOT_NAV_UUID && parent.parentNavUuid !== ROOT_NAV_UUID) {
-    throw new Error('New groups can only be created at root or under a top-level group');
-  }
-
-  const title = buildI18nTitle(name, flags.en);
-  await postNavAction(appType, 'save', {
-    parentNavUuid: parent.navUuid,
-    title: JSON.stringify(title),
-  }, authRef);
-
-  const updatedList = await fetchNavigationList(appType, authRef);
-  const created = updatedList
-    .filter((node) => node.navType === 'NAV' && getNodeName(node) === name)
-    .sort((a, b) => (b.gmtCreate || 0) - (a.gmtCreate || 0))[0];
-
-  return {
-    success: true,
-    appType,
-    action: 'create',
-    group: created ? normalizeNavNode(created) : { name, parentNavUuid: parent.navUuid },
-  };
+  return createGroupWithIcon(appType, name, flags, authRef, {
+    fetchNavigationList, postNavAction, resolveNode, buildI18nTitle,
+    getNodeName, normalizeNavNode, rootNavUuid: ROOT_NAV_UUID,
+  });
 }
 
 async function renameGroup(appType, value, name, flags, authRef) {
@@ -899,7 +879,7 @@ function printUsage() {
   console.error(`
 Usage:
   openyida nav-group list <appType> [--flat] [--include-system] [--raw]
-  openyida nav-group create <appType> "<groupName>" [--parent <groupNavUuid|groupName>] [--en "<EnglishName>"]
+  openyida nav-group create <appType> "<groupName>" [--parent <groupNavUuid|groupName>] [--en "<EnglishName>"] [--icon auto|<iconName>]
   openyida nav-group rename <appType> <groupNavUuid|groupName> "<newName>" [--en "<EnglishName>"]
   openyida nav-group delete <appType> <groupNavUuid|groupName> [--force]
   openyida nav-group move <appType> <navUuid|formUuid|name> --to <groupNavUuid|groupName|root> [--before <node>] [--after <node>]

package/lib/app/theme-from-design.js

@@ -3,7 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const { CliError } = require('../core/cli-error');
-const { REQUIRED_BRAND_SCALE_TOKENS, validateThemeCssContent, extractThemeColor } = require('./custom-theme');
+const { validateThemeCssContent, extractThemeColor } = require('./custom-theme');
 const { parseDesignDocument, extractDesignTokens } = require('../design/document');
 const { normalizeThemeScopes } = require('./theme-scope');
 const DECLARATIONS = /^[ \t]*(--[\w-]+)\s*:\s*([^;]+);/gm;
@@ -25,23 +25,22 @@ function readDesignTokens(markdown) {
 }
 
 function tokensFromMetadata(metadata) {
-  const tokens = extractDesignTokens(metadata, { strict: false });
-  const missing = REQUIRED_BRAND_SCALE_TOKENS.filter(name => !tokens[name]);
-  if (missing.length) {
-    throw new CliError(`design.md 缺少品牌 token：${missing.join(', ')}`, { code: 'DESIGN_THEME_TOKENS_REQUIRED' });
-  }
-  return tokens;
+  // A design may override only part of the paired CSS. Validate the completed
+  // stylesheet after merging instead of requiring duplicate declarations here.
+  return extractDesignTokens(metadata, { strict: false });
 }
 
-function resolveDesignTokens(metadata) {
+function resolveDesignTokens(metadata, options = {}) {
   const tokens = tokensFromMetadata(metadata);
+  if (options.paired) {return tokens;}
   for (const [alias, source] of Object.entries({
     '--color-brand-1': '--color-brand1-10', '--color-brand-2': '--color-brand1-1',
     '--color-brand-3': '--color-brand1-6', '--color-brand-4': '--color-brand1-9',
   })) {
-    tokens[alias] = tokens[alias] || tokens[source];
+    if (tokens[source]) {tokens[alias] = tokens[alias] || tokens[source];}
   }
-  tokens['--color-group'] = tokens['--color-group'] || [6, 1, 5, 2, 9, 3].map(n => tokens[`--color-brand1-${n}`]).join(', ');
+  const group = [6, 1, 5, 2, 9, 3].map(n => tokens[`--color-brand1-${n}`]);
+  if (group.every(Boolean)) {tokens['--color-group'] = tokens['--color-group'] || group.join(', ');}
   return tokens;
 }
 
@@ -108,10 +107,20 @@ function applyNavigationShape(css, tokens) {
   return block ? `${css.trimEnd()}\n\n${block}\n` : css;
 }
 
-function applyDesignTokens(template, markdown, previousMarkdown) {
+// Template baselines can contain brand expressions; they are comparison data,
+// never CSS output. Completed project tokens still use the normal validator.
+function authoredTokens(node, result = {}) {
+  for (const [name, value] of Object.entries(node || {})) {
+    if (name.startsWith('--')) {result[name] = String(value);}
+    else if (value && typeof value === 'object') {authoredTokens(value, result);}
+  }
+  return result;
+}
+
+function applyDesignTokens(template, markdown, previousMarkdown, options = {}) {
   const metadata = designMetadata(markdown);
   const previousMetadata = previousMarkdown === markdown ? metadata : (previousMarkdown ? designMetadata(previousMarkdown) : null);
-  const tokens = resolveDesignTokens(metadata);
+  const tokens = resolveDesignTokens(metadata, options);
   // Bundled CSS is an authoring template. Fill only unresolved declarations from
   // the completed design before validating and rewriting CSS scopes.
   template = template.replace(/^([ \t]*)(--[\w-]+)(\s*:\s*)([^;\n]+);/gm,
@@ -124,11 +133,14 @@ function applyDesignTokens(template, markdown, previousMarkdown) {
     });
   // Reject damaged templates or existing stylesheets before the scope rewrite.
   validateThemeCssContent(template);
-  const previous = previousMetadata === metadata ? tokens : (previousMetadata ? resolveDesignTokens(previousMetadata) : null);
+  const previous = previousMetadata === metadata ? tokens : (previousMetadata
+    ? (options.paired ? authoredTokens(previousMetadata.tokens) : resolveDesignTokens(previousMetadata)) : null);
   navigationTone(metadata); // Validate platform metadata; it does not select a second palette.
-  template = normalizeThemeScopes(template, navigationTone(previousMetadata || metadata));
-  template = applyNavigationShape(template, tokens);
-  if (previous) {template = restoreRemovedNavigation(template, tokens, previous);}
+  if (!options.paired) {
+    template = normalizeThemeScopes(template, navigationTone(previousMetadata || metadata));
+    template = applyNavigationShape(template, tokens);
+    if (previous) {template = restoreRemovedNavigation(template, tokens, previous);}
+  }
   const changed = Object.fromEntries(Object.entries(tokens).filter(([name, value]) => !previous || previous[name] !== value));
   if (!Object.keys(changed).length) {
     validateThemeCssContent(template);

package/lib/app/theme-source.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { CliError } = require('../core/cli-error');
+const { t } = require('../core/i18n');
+const { parseDesignDocument } = require('../design/document');
+const { DESIGN_SKILL_ROOT, loadThemeIndex } = require('../design-plan/themes');
+const { applyDesignTokens } = require('./theme-from-design');
+const SOURCE = /^\/\* openyida-theme-source: ([a-z0-9-]+) \*\/\r?\n/m;
+
+function sourceId(markdown) {
+  const metadata = parseDesignDocument(markdown, { legacyTokenValues: true }).metadata;
+  return metadata.themeProfile?.sourceThemeId ?? metadata.themeId;
+}
+
+// Resolve only catalog paths, never a project-supplied CSS path or theme directory.
+function themeSource(markdown) {
+  const id = sourceId(markdown);
+  const theme = id && loadThemeIndex().themes.find(item => item.themeId === id);
+  if (id !== undefined && !theme) {
+    throw new CliError(t('design_document.invalid', 'themeProfile.sourceThemeId', 'APPLICATION_STYLE_UNKNOWN'), {
+      code: 'APPLICATION_STYLE_UNKNOWN', details: { themeId: id },
+    });
+  }
+  const relative = theme && theme.mode !== 'creative' ? theme.cssTemplatePath : 'references/theme/app-custom-theme-template.css';
+  const file = path.resolve(DESIGN_SKILL_ROOT, relative);
+  if (!file.startsWith(DESIGN_SKILL_ROOT + path.sep)) {throw new Error('Invalid theme CSS path');}
+  return { id: id || 'legacy', css: fs.readFileSync(file, 'utf8'), paired: theme?.mode === 'template',
+    design: theme?.mode === 'template' ? fs.readFileSync(path.resolve(DESIGN_SKILL_ROOT, theme.templatePath), 'utf8') : undefined };
+}
+
+function generateThemeCss(markdown, existingCss, previousMarkdown) {
+  const source = themeSource(markdown);
+  const marker = existingCss?.match(SOURCE)?.[1];
+  // An exported paired stylesheet is also a valid first-generation input.
+  // Unknown historical CSS cannot safely be relabeled as a different template.
+  const previousId = marker || (previousMarkdown && sourceId(previousMarkdown))
+    || (existingCss?.startsWith(source.css.trimEnd()) ? source.id : 'legacy');
+  if (existingCss !== undefined && previousId !== source.id) {
+    throw new CliError(t('theme_source.conflict'), {
+      code: 'THEME_SOURCE_CONFLICT', details: { previousThemeId: previousId, themeId: source.id },
+    });
+  }
+  const input = existingCss ?? source.css;
+  // The paired CSS wins when its design has a different authored default.
+  // Only project deltas and unresolved brand expressions are instantiated.
+  const css = applyDesignTokens(input, markdown, previousMarkdown ?? source.design, { paired: source.paired });
+  // Keep historical token-only files byte-compatible. Named and creative outputs
+  // retain identity even when the file is renamed or its token snapshot is lost.
+  return source.id === 'legacy' ? css : `/* openyida-theme-source: ${source.id} */\n${css.replace(SOURCE, '')}`;
+}
+
+module.exports = { generateThemeCss, sourceId, themeSource };

package/lib/app/update-app.js

@@ -763,22 +763,11 @@ async function run(args) {
       const postData = querystring.stringify(postDataObj);
       return httpPost(
         auth.baseUrl,
-        `/${params.appType}/query/app/updateAppName.json?_api=Form.updateAppName&_mock=false&_stamp=${Date.now()}`,
+        `/query/app/updateAppName.json?_api=Form.updateAppName&_mock=false&_stamp=${Date.now()}`,
         postData
       );
     }, authRef);
 
-  // Verify the persisted resource before exposing success or a mutation receipt.
-  let nameVerification;
-  if (response && response.success && params.name) {
-    const savedApp = await fetchCurrentApp(params.appType, authRef);
-    const savedName = pickText(savedApp.appName, '');
-    if (savedName !== params.name) {
-      throwCommandError(t('update_app.name_not_persisted'), { code: 'APP_NAME_NOT_PERSISTED' });
-    }
-    nameVerification = { verified: true, name: savedName };
-  }
-
   // 输出结果
   if (response && response.success) {
     const details = [['appType', params.appType]];
@@ -789,7 +778,6 @@ async function run(args) {
       success: true,
       appType: params.appType,
       themeVerification: response.themeVerification,
-      nameVerification,
       navigationVerification: response.navigationVerification,
       ...(params.disableCustomTheme ? { runtimeVerification: { verified: false } } : {}),
       updatedFields: {