@aifabrix/builder 2.49.2 → 2.51.0

package/lib/commands/validate-json.js

@@ -0,0 +1,230 @@
+/**
+ * Offline validate then write *-deploy.json (same quality as validate + same write as json).
+ *
+ * @fileoverview aifabrix validate-json command
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const validate = require('../validation/validate');
+const generator = require('../generator');
+const { listIntegrationAppNames, listBuilderAppNames } = require('../utils/paths');
+const {
+  formatSuccessLine,
+  formatBlockingError,
+  formatWarningLine
+} = require('../utils/cli-test-layout-chalk');
+
+/**
+ * @param {string} appKey
+ * @returns {boolean}
+ */
+function looksLikeExistingFilePath(appKey) {
+  try {
+    return Boolean(appKey && fs.existsSync(appKey) && fs.statSync(appKey).isFile());
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {object} opts
+ * @returns {string[]}
+ */
+function collectBatchAppNames(opts) {
+  const names = [];
+  if (opts.integration === true) {
+    names.push(...listIntegrationAppNames());
+  }
+  if (opts.builder === true) {
+    names.push(...listBuilderAppNames());
+  }
+  return [...new Set(names)];
+}
+
+/**
+ * @param {string} appKey
+ * @param {object} result
+ * @param {string} outFormat
+ */
+function emitManifestLine(appKey, result, outFormat) {
+  if (outFormat === 'json' || !result?.appPath) {
+    return;
+  }
+  try {
+    const { emitManifestMetadataLineIfTTY } = require('../utils/manifest-source-emit');
+    emitManifestMetadataLineIfTTY(logger, {
+      appKey,
+      appPath: result.appPath,
+      envOnly: false,
+      json: false
+    });
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * Validate one app/systemKey; write deploy JSON only when local validate succeeds.
+ * @param {string} appKey
+ * @param {object} [options]
+ * @returns {Promise<{ appKey: string, valid: boolean, validation: object, deploy?: object|null, error?: string }>}
+ */
+async function validateThenWriteDeploy(appKey, options = {}) {
+  let validation;
+  try {
+    validation = await validate.validateAppOrFile(appKey, { ...options, certSync: false });
+  } catch (err) {
+    return {
+      appKey,
+      valid: false,
+      validation: { valid: false, errors: [err.message || String(err)] },
+      deploy: null,
+      error: err.message || String(err)
+    };
+  }
+  if (!validation.valid) {
+    return { appKey, valid: false, validation, deploy: null };
+  }
+  const deploy = await generator.generateDeployJsonWithValidation(appKey, options);
+  const ok = deploy.success === true;
+  return {
+    appKey,
+    valid: ok,
+    validation,
+    deploy,
+    error: ok ? undefined : (deploy.validation?.errors || []).join('; ') || 'deploy JSON validation failed'
+  };
+}
+
+/**
+ * @param {object} item
+ * @param {string} outFormat
+ */
+function displayOneHumanResult(item, outFormat) {
+  emitManifestLine(item.appKey, item.validation, outFormat);
+  if (outFormat === 'json') {
+    return;
+  }
+  validate.displayValidationResults(item.validation);
+  if (!item.validation.valid) {
+    logger.log(formatBlockingError(`Skipped deploy JSON for ${item.appKey} (validation failed)`));
+    return;
+  }
+  if (item.deploy?.success && item.deploy.path) {
+    logger.log(formatSuccessLine(`Generated deployment JSON: ${item.deploy.path}`));
+    const warnings = item.deploy.validation?.warnings || [];
+    if (warnings.length > 0) {
+      warnings.forEach((w) => logger.log(formatWarningLine(w)));
+    }
+    return;
+  }
+  logger.log(formatBlockingError(`Deploy JSON write failed for ${item.appKey}`));
+  (item.deploy?.validation?.errors || []).forEach((e) => logger.log(`   • ${e}`));
+}
+
+/**
+ * @param {Array<object>} items
+ * @param {string} outFormat
+ */
+function displayBatchSummary(items, outFormat) {
+  if (outFormat === 'json') {
+    logger.log(JSON.stringify({
+      batch: true,
+      valid: items.every((i) => i.valid),
+      results: items.map((i) => ({
+        appKey: i.appKey,
+        valid: i.valid,
+        path: i.deploy?.path || null,
+        error: i.error || null
+      }))
+    }, null, 2));
+    return;
+  }
+  const passed = items.filter((i) => i.valid);
+  const failed = items.filter((i) => !i.valid);
+  logger.log('');
+  logger.log(chalk.bold('validate-json summary'));
+  logger.log(`  Passed: ${passed.length}`);
+  logger.log(`  Failed: ${failed.length}`);
+  failed.forEach((i) => {
+    logger.log(formatBlockingError(`${i.appKey}${i.error ? `: ${i.error}` : ''}`));
+  });
+}
+
+/**
+ * @param {object} opts
+ * @param {string} outFormat
+ * @returns {Promise<{ exitCode: number }>}
+ */
+async function runValidateJsonBatch(opts, outFormat) {
+  const names = collectBatchAppNames(opts);
+  const items = [];
+  for (const name of names) {
+    const item = await validateThenWriteDeploy(name, opts);
+    displayOneHumanResult(item, outFormat);
+    items.push(item);
+  }
+  displayBatchSummary(items, outFormat);
+  return { exitCode: items.every((i) => i.valid) ? 0 : 1 };
+}
+
+/**
+ * @param {string} appKey
+ * @param {object} opts
+ * @param {string} outFormat
+ * @returns {Promise<{ exitCode: number }>}
+ */
+async function runValidateJsonSingle(appKey, opts, outFormat) {
+  if (looksLikeExistingFilePath(appKey)) {
+    logger.log(
+      chalk.red(
+        'validate-json requires an appKey or systemKey (not a file path). Use aifabrix validate <file> for files.'
+      )
+    );
+    return { exitCode: 1 };
+  }
+  const item = await validateThenWriteDeploy(appKey, opts);
+  if (outFormat === 'json') {
+    logger.log(JSON.stringify({
+      appKey: item.appKey,
+      valid: item.valid,
+      path: item.deploy?.path || null,
+      validation: item.validation,
+      error: item.error || null
+    }, null, 2));
+  } else {
+    displayOneHumanResult(item, outFormat);
+  }
+  return { exitCode: item.valid ? 0 : 1 };
+}
+
+/**
+ * @param {string|undefined} appKey
+ * @param {object} options - Commander options or opts()
+ * @returns {Promise<{ exitCode: number }>}
+ */
+async function runValidateJsonCommand(appKey, options) {
+  const opts = options.opts ? options.opts() : options;
+  const outFormat = (opts.format || 'default').toLowerCase();
+  if (opts.integration === true || opts.builder === true) {
+    return runValidateJsonBatch(opts, outFormat);
+  }
+  if (!appKey || typeof appKey !== 'string') {
+    logger.log(chalk.red('App or system key is required, or use --integration / --builder'));
+    return { exitCode: 1 };
+  }
+  return runValidateJsonSingle(appKey, opts, outFormat);
+}
+
+module.exports = {
+  runValidateJsonCommand,
+  validateThenWriteDeploy,
+  collectBatchAppNames,
+  looksLikeExistingFilePath
+};

package/lib/commands/verify-governance-combined-external.js

@@ -36,7 +36,7 @@ async function runVerifyGovernanceCombined(systemKey, options = {}) {
 
   const pipelineOpts = {
     ...options,
-    noSync: true,
+    noPublish: true,
     authConfig,
     dataplaneUrl
   };

package/lib/commands/verify-governance-db.js

@@ -10,7 +10,7 @@ const {
 } = require('./test-e2e-external');
 const { runDatasourceGovernanceScenarios, getDatasourceGovernancePack } = require('../api/governance-scenario-pack.api');
 const { resolveIntegrationAuth } = require('../external-system/integration-auth-context');
-const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+const { cliOptsSkipPublish } = require('../utils/cli-sync-options');
 const { VERDICT } = require('../lifecycle/product-model');
 const { runWithVerifyStepProgress } = require('../lifecycle/verify-step-progress');
 
@@ -81,7 +81,7 @@ async function runVerifyGovernanceFromDbPacks(systemKey, options) {
     return { resolvedKey, datasourceRows: [] };
   }
 
-  if (!cliOptsSkipSync(options)) {
+  if (!cliOptsSkipPublish(options)) {
     const uploadCtx = await syncLocalIfRequested(resolvedKey, options);
     attachUploadAuthToOptions(options, uploadCtx);
   }

package/lib/commands/verify-operations-command-action.js

@@ -8,7 +8,7 @@
 
 const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
-const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+const { cliOptsSkipPublish } = require('../utils/cli-sync-options');
 const { runVerifyOperationsForExternalSystem } = require('./verify-operations-external');
 const { displayVerifyOperationsTTY } = require('../lifecycle/report-display');
 const { exitCodeFromVerdict } = require('../lifecycle/exit-codes');
@@ -27,7 +27,7 @@ function normalizeVerifyOperationsCliOptions(options, cmd) {
     verbose: options.verbose === true || has('-v') || has('--verbose'),
     debug: options.debug === true || has('-d') || has('--debug'),
     json: options.json === true || has('--json'),
-    noSync: cliOptsSkipSync(options, cmd),
+    noPublish: cliOptsSkipPublish(options, cmd),
     continue: options.continue === true || has('--continue'),
     async: options.async !== false
   };

package/lib/commands/verify-operations-step-plan.js

@@ -8,58 +8,96 @@ const { validateExternalSystemComplete } = require('../validation/validate');
 const { testExternalSystem, testExternalSystemIntegration } = require('../external-system/test');
 const { runTestE2EForExternalSystem } = require('./test-e2e-external');
 
+/**
+ * @param {string} systemKey
+ * @returns {Array}
+ */
+function buildBeforeSyncSteps(systemKey) {
+  return [
+    {
+      key: 'validation',
+      run: () => validateExternalSystemComplete(systemKey, { type: 'external' }),
+      ok: (result) => result.valid === true
+    },
+    {
+      key: 'unit',
+      run: () => testExternalSystem(systemKey, { verbose: false }),
+      ok: (result) => result.valid === true
+    }
+  ];
+}
+
 /**
  * @param {string} systemKey
  * @param {Object} options
- * @returns {{ beforeSync: Array, afterSync: Array, e2e: Object }}
+ * @returns {Array}
  */
-function buildOperationsVerifyStepPlan(systemKey, options) {
-  return {
-    beforeSync: [
-      {
-        key: 'validation',
-        run: () => validateExternalSystemComplete(systemKey, { type: 'external' }),
-        ok: (result) => result.valid === true
-      },
-      {
-        key: 'unit',
-        run: () => testExternalSystem(systemKey, { verbose: false }),
-        ok: (result) => result.valid === true
-      }
-    ],
-    afterSync: [
-      {
-        key: 'integration',
-        run: () =>
-          testExternalSystemIntegration(systemKey, {
-            environment: options.env,
-            noSync: true,
-            verbose: false,
-            debug: options.debug === true
-          }),
-        ok: (result) => result.success === true
-      }
-    ],
-    e2e: {
-      key: 'e2e',
-      run: (progress) =>
-        runTestE2EForExternalSystem(systemKey, {
-          env: options.env,
-          noSync: true,
+function buildAfterSyncSteps(systemKey, options) {
+  return [
+    {
+      key: 'integration',
+      run: () =>
+        testExternalSystemIntegration(systemKey, {
+          environment: options.env || options.environment,
+          noPublish: true,
           verbose: false,
           debug: options.debug === true,
-          async: options.async !== false,
+          // Token-forward (builder-api certify): same auth as E2E step — do not
+          // fall back to getDeploymentAuth inside the container.
           authConfig: options.authConfig,
           dataplaneUrl: options.dataplaneUrl,
-          silentResolve: options.silentResolve === true,
-          quietPollUi: true,
-          onDatasourceProgress: progress?.setLabel
-            ? ({ key, index, total }) =>
-              progress.setLabel(`Running E2E: ${key} (${index + 1}/${total})`)
-            : undefined
+          silentResolve: options.silentResolve === true
         }),
       ok: (result) => result.success === true
     }
+  ];
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {Object}
+ */
+function buildE2eStep(systemKey, options) {
+  if (options.skipE2e === true || options.minimal === true) {
+    return {
+      key: 'e2e',
+      run: async() => ({ success: true, skipped: true, reason: 'minimal' }),
+      ok: () => true
+    };
+  }
+  return {
+    key: 'e2e',
+    run: (progress) =>
+      runTestE2EForExternalSystem(systemKey, {
+        env: options.env,
+        noPublish: true,
+        verbose: false,
+        debug: options.debug === true,
+        async: options.async !== false,
+        authConfig: options.authConfig,
+        dataplaneUrl: options.dataplaneUrl,
+        silentResolve: options.silentResolve === true,
+        quietPollUi: true,
+        onDatasourceProgress: progress?.setLabel
+          ? ({ key, index, total }) =>
+            progress.setLabel(`Running E2E: ${key} (${index + 1}/${total})`)
+          : undefined
+      }),
+    ok: (result) => result.success === true
+  };
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {{ beforeSync: Array, afterSync: Array, e2e: Object }}
+ */
+function buildOperationsVerifyStepPlan(systemKey, options) {
+  return {
+    beforeSync: buildBeforeSyncSteps(systemKey),
+    afterSync: buildAfterSyncSteps(systemKey, options),
+    e2e: buildE2eStep(systemKey, options)
   };
 }
 

package/lib/commands/verify-operations-steps.js

@@ -5,7 +5,7 @@
 'use strict';
 
 const { syncLocalIfRequested } = require('./test-e2e-external');
-const { cliOptsSkipSync } = require('../utils/cli-sync-options');
+const { cliOptsSkipPublish } = require('../utils/cli-sync-options');
 const { buildOperationsVerifyStepPlan } = require('./verify-operations-step-plan');
 const { runWithVerifyStepProgress } = require('../lifecycle/verify-step-progress');
 
@@ -86,7 +86,7 @@ async function runOperationsVerifySteps(systemKey, options) {
     }
   }
 
-  if (!cliOptsSkipSync(options)) {
+  if (!cliOptsSkipPublish(options)) {
     const uploadCtx = await syncLocalIfRequested(systemKey, options);
     attachUploadAuthToOptions(options, uploadCtx);
   }

package/lib/commands/verify-trust-command-action.js

@@ -28,7 +28,7 @@ async function runVerifyTrustCommandAction(appName, options, cmd) {
     env: opts.env,
     verbose: opts.verbose,
     debug: opts.debug,
-    noSync: opts.noSync === true,
+    noPublish: opts.noPublish === true,
     revalidate: opts.revalidate === true,
     timeout: opts.timeout
   });

package/lib/commands/wizard-core.js

@@ -468,7 +468,7 @@ async function handleFileSaving(appName, systemConfig, datasourceConfigs, system
   const spinner = ora('Saving files...').start();
   try {
     const config = require('../core/config');
-    const format = (await config.getFormat()) || 'yaml';
+    const format = ctx?.format || (await config.getFormat()) || 'yaml';
     const generatedFiles = await generateWizardFiles(appName, systemConfig, datasourceConfigs, systemKey, { aiGeneratedReadme: null, format });
     if (enableRBAC && generatedFiles.appPath && generatedFiles.systemFilePath) {
       try {

package/lib/commands/wizard-headless.js

@@ -115,7 +115,8 @@ async function executeWizardFromConfig(wizardConfig, dataplaneUrl, authConfig, o
     {
       dataplaneUrl,
       authConfig,
-      enableRBAC: Boolean(preferences?.enableRBAC)
+      enableRBAC: Boolean(preferences?.enableRBAC),
+      format: opts.format
     }
   );
 }

package/lib/core/admin-secrets.js

@@ -33,12 +33,8 @@ function needsAdminEnvQuoting(value) {
  * @returns {string}
  */
 function formatAdminEnvLine(key, value) {
-  const safe = String(value ?? '').replace(/\n/g, ' ').trim();
-  if (!needsAdminEnvQuoting(safe)) {
-    return `${key}=${safe}`;
-  }
-  const escaped = safe.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-  return `${key}="${escaped}"`;
+  const { formatDotenvLine } = require('../utils/env-dotenv-format');
+  return formatDotenvLine(key, value);
 }
 
 /**

package/lib/core/audit-logger.js

@@ -238,7 +238,7 @@ async function logApiCall({ url, options, statusCode, duration, success, errorIn
   const path = extractPathFromUrl(url);
 
   // Extract controller URL from full URL
-  let controllerUrl = 'unknown';
+  let controllerUrl;
   try {
     const urlObj = new URL(url);
     controllerUrl = `${urlObj.protocol}//${urlObj.host}`;

package/lib/core/secrets-env-content.js

@@ -236,6 +236,7 @@ function parseEnvContentToMap(content) {
   if (!content || typeof content !== 'string') {
     return {};
   }
+  const { parseDotenvRawValue } = require('../utils/env-dotenv-format');
   const map = {};
   const lines = content.split(/\r?\n/);
   for (const line of lines) {
@@ -246,8 +247,7 @@ function parseEnvContentToMap(content) {
     const eq = trimmed.indexOf('=');
     if (eq > 0) {
       const key = trimmed.substring(0, eq).trim();
-      const value = trimmed.substring(eq + 1);
-      map[key] = value;
+      map[key] = parseDotenvRawValue(trimmed.substring(eq + 1));
     }
   }
   return map;
@@ -279,7 +279,12 @@ function collectSeenKeysAndMergeEnvLines(lines, newMap) {
     if (eq > 0) {
       const key = trimmed.substring(0, eq).trim();
       seen.add(key);
-      out.push(Object.prototype.hasOwnProperty.call(newMap, key) ? `${key}=${newMap[key]}` : line);
+      if (Object.prototype.hasOwnProperty.call(newMap, key)) {
+        const { formatDotenvLine } = require('../utils/env-dotenv-format');
+        out.push(formatDotenvLine(key, newMap[key]));
+      } else {
+        out.push(line);
+      }
       continue;
     }
     out.push(line);
@@ -288,9 +293,10 @@ function collectSeenKeysAndMergeEnvLines(lines, newMap) {
 }
 
 function appendMissingEnvKeysFromMap(out, seen, newMap) {
+  const { formatDotenvLine } = require('../utils/env-dotenv-format');
   for (const key of Object.keys(newMap)) {
     if (!seen.has(key)) {
-      out.push(`${key}=${newMap[key]}`);
+      out.push(formatDotenvLine(key, newMap[key]));
     }
   }
 }

package/lib/core/secrets-env-write.js

@@ -130,19 +130,8 @@ async function injectBashPrefixedExportLines(content, secretsPath, appName) {
  * @returns {Object.<string, string>} Map of variable name to value
  */
 function parseEnvContentToMap(content) {
-  const map = {};
-  if (!content || typeof content !== 'string') return map;
-  const lines = content.split(/\r?\n/);
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const eq = trimmed.indexOf('=');
-    if (eq > 0) {
-      const key = trimmed.substring(0, eq).trim();
-      map[key] = trimmed.substring(eq + 1);
-    }
-  }
-  return map;
+  const { parseEnvContentToMap: parseMap } = require('./secrets-env-content');
+  return parseMap(content);
 }
 
 /**

package/lib/core/secrets-load.js

@@ -133,9 +133,7 @@ function mergeUserWithConfigFile(userSecrets, resolvedConfigPath, keySources) {
   for (const key of Object.keys(configSecrets)) {
     if (!(key in merged) || merged[key] === undefined || merged[key] === null || merged[key] === '') {
       merged[key] = configSecrets[key];
-      if (keySources) {
-        keySources[key] = resolvedConfigPath;
-      }
+      keySources[key] = resolvedConfigPath;
     }
   }
   return merged;

package/lib/datasource/agent-trust-run.js

@@ -17,8 +17,8 @@ const { requireBearerForDataplanePipeline } = require('../utils/token-manager');
 const { buildMinimalUploadSyncOptions } = require('../utils/upload-sync-options');
 const { fetchTrustRunFromDataplane } = require('./agent-trust-fetch');
 
-async function maybeSyncBeforeTrust({ noSync, authConfig, systemKey, options = {} }) {
-  if (noSync === true) return;
+async function maybeSyncBeforeTrust({ noPublish, authConfig, systemKey, options = {} }) {
+  if (noPublish === true) return;
   requireBearerForDataplanePipeline(authConfig);
   logger.log(chalk.cyan('Syncing local config to dataplane…'));
   const { uploadExternalSystem } = require('../commands/upload');
@@ -66,7 +66,7 @@ async function runDatasourceAgentTrust(datasourceKey, options = {}) {
   }
 
   await maybeSyncBeforeTrust({
-    noSync: options.noSync === true,
+    noPublish: options.noPublish === true,
     authConfig,
     systemKey,
     options

package/lib/datasource/capability/relate-operations.js

@@ -23,7 +23,7 @@ function _asObject(x) {
 function _uniqStrings(list) {
   const out = [];
   const seen = new Set();
-  for (const x of list || []) {
+  for (const x of list) {
     const s = String(x || '').trim();
     if (!s || seen.has(s)) continue;
     seen.add(s);

package/lib/datasource/deploy.js

@@ -255,7 +255,9 @@ async function deployDatasource(fileOrKey, _options) {
   }
 
   if (Array.isArray(datasourceConfig.configuration) && datasourceConfig.configuration.length > 0) {
-    const { envMap, secrets } = await buildResolvedEnvMapForIntegration(systemKey);
+    const { envMap, secrets } = await buildResolvedEnvMapForIntegration(systemKey, {
+      dataplaneRuntime: true
+    });
     resolveConfigurationValues(datasourceConfig.configuration, envMap, secrets, systemKey);
   }
 

package/lib/datasource/test-e2e.js

@@ -40,6 +40,8 @@ function buildUnifiedE2eRunOptions(options, timeoutMs, pk) {
     minProcessed: options.minProcessed,
     minRecordCount: options.minRecordCount,
     capabilityKey: options.capabilityKey,
+    version: options.version,
+    syncMode: options.syncMode,
     timeout: timeoutMs,
     sync: options.sync === true,
     force: options.force === true,
@@ -114,10 +116,13 @@ function resolveE2ePollTimeoutMs(options) {
  * @returns {Object}
  */
 function buildE2eRequestMeta(datasourceKey, options, pk) {
+  const includeDebug = includeDebugForRequest(options.debug);
   return {
     datasourceKey,
     runType: 'e2e',
-    includeDebug: includeDebugForRequest(options.debug),
+    includeDebug,
+    explainCertification: includeDebug,
+    explainMetrics: includeDebug,
     cleanup: options.cleanup,
     runScenarios: options.runScenarios,
     primaryKeyValue: pk !== undefined && pk !== null,

package/lib/datasource/unified-validation-run-body.js

@@ -53,14 +53,17 @@ async function buildUnifiedValidationBody(params) {
       })
       : undefined;
 
+  const includeDebug = includeDebugForRequest(options.debug);
   const body = buildExternalDataSourceValidationRequest({
     systemKey,
     datasourceKey,
     runType,
     payloadTemplate,
     asyncRun: runType === 'e2e' && useAsync === true,
-    includeDebug: includeDebugForRequest(options.debug),
+    includeDebug,
     explain: options.verbose === true,
+    explainCertification: includeDebug,
+    explainMetrics: includeDebug,
     e2eOptions: e2eOptions && Object.keys(e2eOptions).length > 0 ? e2eOptions : undefined
   });
   return withStageOnValidationRunBody(body, runType);

package/lib/datasource/unified-validation-run.js

@@ -121,7 +121,7 @@ async function runUnifiedDatasourceValidation(datasourceKey, options) {
 
   const ctx = await prepareValidationRunContext(datasourceKey, options);
   const useAsync = options.noAsync ? false : options.async !== false;
-  const timeoutMs = parseInt(String(options.timeout || '30000'), 10) || 30000;
+  const timeoutMs = parseInt(String(options.timeout || '60000'), 10) || 60000;
   const body = await buildUnifiedValidationBody({
     systemKey: ctx.systemKey,
     datasourceKey,