@aifabrix/builder 2.46.0 → 2.47.1

package/lib/commands/setup-prompts-platform-mode.js

@@ -1,5 +1,5 @@
 /**
- * Setup prompts for platform topology mode (single vs full).
+ * Setup prompts for platform topology mode (single vs single-traefik; full via CLI only).
  *
  * @fileoverview Setup platform mode prompt + CLI option normalization
  * @author AI Fabrix Team
@@ -9,31 +9,43 @@
 'use strict';
 
 const inquirer = require('inquirer');
-const { normalizeSetupPlatformMode, SETUP_PLATFORM_MODE } = require('../core/setup-platform-mode');
+const {
+  normalizeSetupPlatformMode,
+  SETUP_PLATFORM_MODE,
+  SETUP_PLATFORM_MODE_CLI_VALUES,
+  getSetupPlatformModePromptChoices
+} = require('../core/setup-platform-mode');
 
 /**
  * Resolve platform mode from CLI options, if provided.
  * @param {Object} [options]
- * @returns {'single'|'full'|null}
+ * @returns {'single'|'single-traefik'|'full'|null}
  */
 function resolvePlatformModeFromOptions(options = {}) {
   const raw = options.platform;
   if (raw === undefined || raw === null || String(raw).trim() === '') {
     return null;
   }
-  const normalized = normalizeSetupPlatformMode(raw);
-  // Guard: only accept exact canonical values from CLI; reject unexpected to avoid silent typos.
   const rawNorm = String(raw).trim().toLowerCase();
-  if (rawNorm !== 'single' && rawNorm !== 'full') {
-    throw new Error('--platform must be single or full (example: aifabrix setup --platform full)');
+  const isCanonical = SETUP_PLATFORM_MODE_CLI_VALUES.includes(rawNorm);
+  const isAlias =
+    rawNorm === 'ingress' ||
+    rawNorm === 'single-ingress' ||
+    rawNorm === 'traefik' ||
+    rawNorm === 'all' ||
+    rawNorm === 'full-platform' ||
+    rawNorm === 'platform-full';
+  if (!isCanonical && !isAlias) {
+    const allowed = SETUP_PLATFORM_MODE_CLI_VALUES.join(', ');
+    throw new Error(`--platform must be one of: ${allowed} (example: aifabrix setup --platform single-traefik)`);
   }
-  return normalized;
+  return normalizeSetupPlatformMode(raw);
 }
 
 /**
  * @async
  * @param {Object} [options]
- * @returns {Promise<'single'|'full'>}
+ * @returns {Promise<'single'|'single-traefik'|'full'>}
  */
 async function promptSetupPlatformMode(options = {}) {
   const fromCli = resolvePlatformModeFromOptions(options);
@@ -44,16 +56,7 @@ async function promptSetupPlatformMode(options = {}) {
       type: 'list',
       name: 'mode',
       message: 'Platform mode:',
-      choices: [
-        {
-          name: 'Single environment — direct ports (no Traefik front door)',
-          value: SETUP_PLATFORM_MODE.SINGLE
-        },
-        {
-          name: 'Full platform — Traefik front door + miso/dev/tst/pro (shared infra)',
-          value: SETUP_PLATFORM_MODE.FULL
-        }
-      ],
+      choices: getSetupPlatformModePromptChoices(),
       default: SETUP_PLATFORM_MODE.SINGLE
     }
   ]);
@@ -62,6 +65,6 @@ async function promptSetupPlatformMode(options = {}) {
 
 module.exports = {
   resolvePlatformModeFromOptions,
-  promptSetupPlatformMode
+  promptSetupPlatformMode,
+  getSetupPlatformModePromptChoices
 };
-

package/lib/commands/test-trust-external.js

@@ -1,7 +1,7 @@
 /**
- * @fileoverview verify-trust <systemKey> — semantic agent metadata validation for all datasources.
+ * @fileoverview verify-trust <systemKey> — dual-confidence AI Trust via dataplane (433.0).
  * @author AI Fabrix Team
- * @version 1.0.0
+ * @version 2.0.0
  */
 
 'use strict';
@@ -10,83 +10,20 @@ const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { getConfig } = require('../core/config');
 const { setupIntegrationTestAuth } = require('../external-system/test-auth');
-const { runDatasourceAgentTrust } = require('../datasource/agent-trust-run');
+const { runSystemVerifyTrust } = require('../api/lifecycle.api');
 const {
   resolveExternalIntegrationContext,
   syncLocalIfRequested
 } = require('./test-e2e-external');
 
-function pushTrustResult(results, key, trustRun, apiError) {
-  const failed =
-    apiError ||
-    !trustRun ||
-    trustRun.trustDecision === 'notTrusted' ||
-    trustRun.validationStatus === 'failed';
-  results.push({
-    key,
-    success: !failed,
-    error: failed
-      ? apiError
-        ? apiError.message || String(apiError)
-        : trustRun.summary || 'Trust validation failed'
-      : undefined,
-    trustRun
-  });
-}
-
 /**
  * @async
- * @param {Object|null} uploadCtx
  * @param {string} externalSystem
  * @param {Object} options
- * @returns {Promise<{ authConfig: Object, dataplaneUrl: string }>}
- */
-async function resolveTrustAuthContext(uploadCtx, externalSystem, options) {
-  if (uploadCtx) {
-    return { authConfig: uploadCtx.authConfig, dataplaneUrl: uploadCtx.dataplaneUrl };
-  }
-  const configObj = await getConfig();
-  return setupIntegrationTestAuth(
-    externalSystem,
-    {
-      environment: options.env,
-      authConfig: options.authConfig,
-      dataplaneUrl: options.dataplaneUrl,
-      silentResolve: options.silentResolve === true
-    },
-    configObj
-  );
-}
-
-/**
- * @async
- * @param {string[]} keys
- * @param {Object} runOpts
- * @param {Array<Object>} results
- */
-async function runTrustForDatasourceKeys(keys, runOpts, results) {
-  for (const key of keys) {
-    try {
-      const { trustRun, apiError } = await runDatasourceAgentTrust(key, runOpts);
-      pushTrustResult(results, key, trustRun, apiError);
-    } catch (err) {
-      results.push({ key, success: false, error: err.message, trustRun: null });
-    }
-  }
-}
-
-/**
- * @async
- * @param {string} externalSystem
- * @param {Object} options
- * @returns {Promise<{ success: boolean, results: Array<Object>, systemKey: string }>}
+ * @returns {Promise<{ success: boolean, results: Array<Object>, systemKey: string, trustReport?: Object }>}
  */
 async function runTestTrustForExternalSystem(externalSystem, options = {}) {
-  const { systemKey, keys } = resolveExternalIntegrationContext(externalSystem);
-  if (keys.length === 0) {
-    logger.log(chalk.yellow(`No datasources found for ${externalSystem}.`));
-    return { success: true, results: [], systemKey };
-  }
+  const { systemKey } = resolveExternalIntegrationContext(externalSystem);
 
   const uploadCtx = await syncLocalIfRequested(systemKey, options);
   if (uploadCtx?.authConfig && uploadCtx?.dataplaneUrl) {
@@ -95,30 +32,42 @@ async function runTestTrustForExternalSystem(externalSystem, options = {}) {
     options.silentResolve = true;
   }
   if (options.revalidate === true) {
-    logger.log(chalk.cyan('Forcing revalidation (cache bypass) for each datasource…'));
+    logger.log(chalk.cyan('Forcing revalidation (cache bypass)…'));
   }
 
-  const { authConfig, dataplaneUrl } = await resolveTrustAuthContext(
-    uploadCtx,
-    externalSystem,
-    options
-  );
-  const results = [];
-  await runTrustForDatasourceKeys(
-    keys,
-    {
-      app: externalSystem,
-      environment: options.env,
-      noSync: true,
-      revalidate: options.revalidate === true,
-      summary: options.summary === true,
-      timeout: options.timeout,
-      authConfig,
-      dataplaneUrl
-    },
-    results
-  );
-  return { success: results.every(r => r.success), results, systemKey };
+  let authConfig = options.authConfig;
+  let dataplaneUrl = options.dataplaneUrl;
+  if (!authConfig || !dataplaneUrl) {
+    const configObj = await getConfig();
+    const auth = await setupIntegrationTestAuth(
+      externalSystem,
+      {
+        environment: options.env,
+        authConfig: options.authConfig,
+        dataplaneUrl: options.dataplaneUrl,
+        silentResolve: options.silentResolve === true
+      },
+      configObj
+    );
+    authConfig = auth.authConfig;
+    dataplaneUrl = auth.dataplaneUrl;
+  }
+
+  const trustReport = await runSystemVerifyTrust(dataplaneUrl, authConfig, systemKey, {
+    forceRevalidate: options.revalidate === true
+  });
+
+  const results = (trustReport.datasourceRows || []).map(row => ({
+    key: row.datasourceKey,
+    success: trustReport.verdict === 'VERIFIED' || trustReport.verdict !== 'FAILED',
+    trustRun: {
+      trustDecision: row.trustDecision,
+      validationStatus: row.validationStatus
+    }
+  }));
+
+  const success = trustReport.verdict === 'VERIFIED';
+  return { success, results, systemKey, trustReport };
 }
 
 module.exports = {

package/lib/commands/up-common.js

@@ -328,6 +328,35 @@ async function ensureAppFromTemplate(appName, opts = {}) {
   return primaryCopied;
 }
 
+/** Dataplane app key materialized for dataplane install (worker/beat are compose sidecars). */
+const DATAPLANE_BUILDER_APP_KEYS = Object.freeze(['dataplane']);
+
+/** Builder dirs removed on up-platform / setup force (includes Celery companions). */
+const PLATFORM_BUILDER_CLEAN_APP_KEYS = Object.freeze([
+  'keycloak',
+  'miso-controller',
+  ...DATAPLANE_BUILDER_APP_KEYS
+]);
+
+/**
+ * Ensure dataplane application manifest exists under the builder root.
+ * Worker/beat sidecars are resolved from parent application.yaml at run/compose time.
+ *
+ * @param {object} [opts]
+ * @param {boolean} [opts.silent]
+ * @returns {Promise<boolean>} True if any app template was copied
+ */
+async function ensureDataplaneAppsFromTemplate(opts = {}) {
+  let anyCopied = false;
+  for (const appName of DATAPLANE_BUILDER_APP_KEYS) {
+    const copied = await ensureAppFromTemplate(appName, opts);
+    if (copied) {
+      anyCopied = true;
+    }
+  }
+  return anyCopied;
+}
+
 /**
  * Merge builder/packages `application.yaml` into `~/.aifabrix/urls.local.yaml`.
  * Same scan as the end of {@link prepareUrlsLocalRegistryForUpPlatform}; call after platform app
@@ -354,14 +383,17 @@ async function prepareUrlsLocalRegistryForUpPlatform(opts = {}) {
   const templateOpts = { silent: Boolean(opts.silent) };
   await ensureAppFromTemplate('keycloak', templateOpts);
   await ensureAppFromTemplate('miso-controller', templateOpts);
-  await ensureAppFromTemplate('dataplane', templateOpts);
+  await ensureDataplaneAppsFromTemplate(templateOpts);
   refreshUrlsLocalRegistryForCurrentProject();
 }
 
 module.exports = {
   applyUpPlatformForceConfig,
   cleanBuilderAppDirs,
+  DATAPLANE_BUILDER_APP_KEYS,
+  PLATFORM_BUILDER_CLEAN_APP_KEYS,
   ensureAppFromTemplate,
+  ensureDataplaneAppsFromTemplate,
   patchEnvOutputPathForDeployOnly,
   validateEnvOutputPathFolderOrNull,
   getEnvOutputPathFolder,

package/lib/commands/up-dataplane.js

@@ -29,7 +29,12 @@ const { checkHealthEndpoint } = require('../utils/health-check');
 const { validateControllerUrl } = require('../utils/auth-config-validator');
 const app = require('../app');
 const { assertDevInfraUp } = require('./dev-infra-gate');
-const { ensureAppFromTemplate, validateEnvOutputPathFolderOrNull, refreshUrlsLocalRegistryForCurrentProject } = require('./up-common');
+const { dataplaneDockerHostPort } = require('../utils/declarative-url-ports');
+const {
+  ensureDataplaneAppsFromTemplate,
+  validateEnvOutputPathFolderOrNull,
+  refreshUrlsLocalRegistryForCurrentProject
+} = require('./up-common');
 
 const CONTROLLER_HEALTH_PATH = '/health';
 
@@ -198,8 +203,7 @@ function computeDataplanePortOverride(runEnvKey, developerIdNum) {
   if (runEnvKey !== 'dev' && runEnvKey !== 'tst') {
     return undefined;
   }
-  const baseHostPort = 3001 + (Number.isFinite(developerIdNum) ? developerIdNum : 0) * 100;
-  return runEnvKey === 'dev' ? baseHostPort + 10 : baseHostPort + 20;
+  return dataplaneDockerHostPort(3001, developerIdNum, runEnvKey);
 }
 
 function assertDevEnvironmentForDataplane(cfg) {
@@ -243,7 +247,7 @@ async function handleUpDataplane(options = {}) {
       : await resolveEnvironment();
   const { controllerUrl, authConfig } = await resolveUpDataplaneAuthContext(options, environmentKey);
 
-  await ensureAppFromTemplate('dataplane');
+  await ensureDataplaneAppsFromTemplate();
   // If envOutputPath target folder does not exist, set envOutputPath to null
   validateEnvOutputPathFolderOrNull('dataplane');
 

package/lib/commands/upload.js

@@ -32,6 +32,7 @@ const {
   resolveConfigurationValues,
   collectResolvedVariableConfigurationNames
 } = require('../utils/configuration-env-resolver');
+const { pushRuntimeConfigurationValues } = require('../utils/runtime-configuration-values');
 const { validateExternalSystemComplete } = require('../validation/validate');
 const { displayValidationResults } = require('../validation/validate-display');
 const { generateControllerManifest } = require('../generator/external-controller-manifest');
@@ -219,6 +220,24 @@ async function pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey,
   if (pushResult.warning) {
     logger.log(chalk.yellow(`Warning: ${pushResult.warning}`));
   }
+  try {
+    const configPush = await pushRuntimeConfigurationValues(
+      dataplaneUrl,
+      authConfig,
+      systemKey,
+      payload
+    );
+    if (configPush.pushed > 0) {
+      const nameList = configPush.names.length ? ` (${configPush.names.join(', ')})` : '';
+      logger.log(
+        formatSuccessLine(
+          `Stored ${configPush.pushed} runtime configuration value(s) in dataplane${nameList}.`
+        )
+      );
+    }
+  } catch (err) {
+    logger.log(chalk.yellow(`Warning: runtime configuration store skipped: ${err.message}`));
+  }
 }
 
 /**
@@ -314,7 +333,7 @@ async function buildValidatedUploadManifestPayload(systemKey, opts = {}) {
  * @param {Object} manifest
  * @returns {Promise<void>}
  */
-async function logAndSyncLocalOpenApiForUpload(systemKey, manifest) {
+async function logAndSyncLocalOpenApiForUpload(systemKey, manifest, uploadContext = {}) {
   const appPath = getIntegrationPath(systemKey);
   const ei = manifest && manifest.externalIntegration;
   const datasourceFiles = ei && Array.isArray(ei.dataSources) ? ei.dataSources : [];
@@ -323,7 +342,9 @@ async function logAndSyncLocalOpenApiForUpload(systemKey, manifest) {
     dryRun: false,
     appPath,
     systemKey,
-    datasourceFiles
+    datasourceFiles,
+    dataplaneUrl: uploadContext.dataplaneUrl,
+    authConfig: uploadContext.authConfig
   });
   for (const line of openapiSyncLines) {
     logger.log(line.startsWith('Skipped') ? formatWarningLine(line) : formatSuccessLine(line));
@@ -372,7 +393,7 @@ async function runUploadPublishAndSummary(systemKey, options, manifest, payload)
   await pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey, payload, {
     json: options.json === true
   });
-  await logAndSyncLocalOpenApiForUpload(systemKey, manifest);
+  await logAndSyncLocalOpenApiForUpload(systemKey, manifest, { dataplaneUrl, authConfig });
   await handlePublicationAndFollowups(
     {
       systemKey,

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

@@ -39,7 +39,10 @@ async function runVerifyTrustCommandAction(appName, options, cmd) {
         systemKey: result.systemKey,
         command: result.command,
         verdict: result.verdict,
-        businessContextConfidencePercent: result.businessContextConfidencePercent,
+        aiTrustPercent: result.aiTrustPercent,
+        accessConfidencePercent: result.accessConfidencePercent,
+        businessConfidencePercent: result.businessConfidencePercent,
+        findings: result.findings,
         datasourceRows: opts.details ? result.datasourceRows : undefined
       },
       opts.details || opts.verbose

package/lib/commands/verify-trust-external.js

@@ -1,17 +1,13 @@
 /**
- * @fileoverview verify-trust orchestration with product-model rollup (plan 150.0).
+ * @fileoverview verify-trust orchestration with dual-confidence report (433.0).
  * @author AI Fabrix Team
- * @version 1.0.0
+ * @version 2.0.0
  */
 
 'use strict';
 
 const { runTestTrustForExternalSystem } = require('./test-trust-external');
-const {
-  VERDICT,
-  verdictFromPassed,
-  worstConfidencePercent
-} = require('../lifecycle/product-model');
+const { VERDICT, verdictFromPassed } = require('../lifecycle/product-model');
 
 /**
  * @param {Array<Object>} rows
@@ -20,14 +16,12 @@ const {
 function mapTrustDatasourceRows(rows) {
   return (rows || []).map(row => {
     const tr = row.trustRun;
-    const confidencePercent =
-      tr && typeof tr.confidence === 'number' ? Math.round(tr.confidence * 100) : null;
     const verdict = row.success ? VERDICT.VERIFIED : VERDICT.FAILED;
     return {
       datasourceKey: row.key,
       verdict,
-      confidencePercent,
       trustDecision: tr?.trustDecision,
+      validationStatus: tr?.validationStatus,
       error: row.error
     };
   });
@@ -40,22 +34,20 @@ function mapTrustDatasourceRows(rows) {
  * @returns {Promise<Object>}
  */
 async function runVerifyTrustForExternalSystem(systemKey, options = {}) {
-  const { success, results, systemKey: resolvedKey } = await runTestTrustForExternalSystem(
-    systemKey,
-    options
-  );
+  const { success, results, systemKey: resolvedKey, trustReport } =
+    await runTestTrustForExternalSystem(systemKey, options);
   const datasourceRows = mapTrustDatasourceRows(results);
-  const confidences = datasourceRows
-    .map(r => (typeof r.confidencePercent === 'number' ? r.confidencePercent / 100 : null))
-    .filter(v => v !== null);
-  const businessContextConfidencePercent = worstConfidencePercent(confidences);
-  const verdict = verdictFromPassed(success);
+  const report = trustReport || {};
+  const verdict = report.verdict ? report.verdict : verdictFromPassed(success);
 
   return {
     systemKey: resolvedKey || systemKey,
     command: 'verify-trust',
     verdict,
-    businessContextConfidencePercent,
+    aiTrustPercent: report.aiTrustPercent ?? null,
+    accessConfidencePercent: report.accessConfidencePercent ?? null,
+    businessConfidencePercent: report.businessConfidencePercent ?? null,
+    findings: Array.isArray(report.findings) ? report.findings : [],
     datasourceRows,
     results
   };

package/lib/core/config-setup-platform-mode.js

@@ -1,5 +1,5 @@
 /**
- * `setupPlatformMode` field in `config.yaml` (`single` | `full`).
+ * `setupPlatformMode` field in `config.yaml` (`single` | `single-traefik` | `full`).
  *
  * @fileoverview Persists setup wizard platform mode
  * @author AI Fabrix Team
@@ -15,7 +15,7 @@ const {
 
 /**
  * @param {() => Promise<Object>} getConfig
- * @returns {Promise<'single'|'full'>}
+ * @returns {Promise<'single'|'single-traefik'|'full'>}
  */
 async function getSetupPlatformModeFromConfig(getConfig) {
   const cfg = await getConfig();
@@ -29,7 +29,7 @@ async function getSetupPlatformModeFromConfig(getConfig) {
  * @param {() => Promise<Object>} getConfig
  * @param {(data: Object) => Promise<void>} saveConfig
  * @param {unknown} mode
- * @returns {Promise<'single'|'full'>}
+ * @returns {Promise<'single'|'single-traefik'|'full'>}
  */
 async function setSetupPlatformModeInConfig(getConfig, saveConfig, mode) {
   const normalized = normalizeSetupPlatformMode(mode);

package/lib/core/setup-platform-mode.js

@@ -1,5 +1,5 @@
 /**
- * Setup platform topology mode (`single` | `full`).
+ * Setup platform topology mode (`single` | `single-traefik` | `full`).
  *
  * This is distinct from `setupInstallationProfile` (dev/pro password bundle) and from
  * the login/run environment (`dev` | `tst` | `pro`).
@@ -14,12 +14,20 @@
 /** @enum {string} */
 const SETUP_PLATFORM_MODE = Object.freeze({
   SINGLE: 'single',
+  SINGLE_TRAEFIK: 'single-traefik',
   FULL: 'full'
 });
 
+/** @type {readonly string[]} */
+const SETUP_PLATFORM_MODE_CLI_VALUES = Object.freeze([
+  SETUP_PLATFORM_MODE.SINGLE,
+  SETUP_PLATFORM_MODE.SINGLE_TRAEFIK,
+  SETUP_PLATFORM_MODE.FULL
+]);
+
 /**
  * @param {unknown} value
- * @returns {'single'|'full'}
+ * @returns {'single'|'single-traefik'|'full'}
  */
 function normalizeSetupPlatformMode(value) {
   const raw = String(value ?? '')
@@ -27,6 +35,8 @@ function normalizeSetupPlatformMode(value) {
     .toLowerCase();
   if (raw === SETUP_PLATFORM_MODE.FULL) return SETUP_PLATFORM_MODE.FULL;
   if (raw === 'all' || raw === 'full-platform' || raw === 'platform-full') return SETUP_PLATFORM_MODE.FULL;
+  if (raw === SETUP_PLATFORM_MODE.SINGLE_TRAEFIK) return SETUP_PLATFORM_MODE.SINGLE_TRAEFIK;
+  if (raw === 'ingress' || raw === 'single-ingress' || raw === 'traefik') return SETUP_PLATFORM_MODE.SINGLE_TRAEFIK;
   return SETUP_PLATFORM_MODE.SINGLE;
 }
 
@@ -34,22 +44,47 @@ function normalizeSetupPlatformMode(value) {
  * Derived config flags for a chosen platform mode.
  *
  * - single: direct ports, no front door ingress
- * - full: enable Traefik ingress + env-scoped resources
+ * - single-traefik: Traefik front door (domain + TLS) for one environment only
+ * - full: Traefik ingress + env-scoped resources (multi-env; CLI only until menu returns)
  *
- * @param {'single'|'full'} mode
+ * @param {'single'|'single-traefik'|'full'} mode
  * @returns {{ traefik: boolean, useEnvironmentScopedResources: boolean }}
  */
 function flagsForSetupPlatformMode(mode) {
   const m = normalizeSetupPlatformMode(mode);
+  const traefik =
+    m === SETUP_PLATFORM_MODE.SINGLE_TRAEFIK || m === SETUP_PLATFORM_MODE.FULL;
   return {
-    traefik: m === SETUP_PLATFORM_MODE.FULL,
+    traefik,
     useEnvironmentScopedResources: m === SETUP_PLATFORM_MODE.FULL
   };
 }
 
+/**
+ * Interactive setup menu choices (full platform hidden until multi-env path ships).
+ *
+ * @returns {{ name: string, value: string }[]}
+ */
+function getSetupPlatformModePromptChoices() {
+  return [
+    {
+      name: 'Single environment — direct ports (no Traefik front door)',
+      value: SETUP_PLATFORM_MODE.SINGLE
+    },
+    {
+      name: 'Single environment — Traefik front door (domain + TLS)',
+      value: SETUP_PLATFORM_MODE.SINGLE_TRAEFIK
+    }
+    // Full platform — Traefik front door + miso/dev/tst/pro (shared infra) — menu returns soon.
+    // { name: 'Full platform — Traefik front door + miso/dev/tst/pro (shared infra)', value: SETUP_PLATFORM_MODE.FULL },
+  ];
+}
+
 module.exports = {
   SETUP_PLATFORM_MODE,
+  SETUP_PLATFORM_MODE_CLI_VALUES,
   normalizeSetupPlatformMode,
-  flagsForSetupPlatformMode
+  flagsForSetupPlatformMode,
+  getSetupPlatformModePromptChoices
 };
 

package/lib/datasource/capability/capability-diff-slice.js

@@ -7,6 +7,7 @@
  */
 
 const { deepClone } = require('./copy-operations');
+const { capabilitiesIncludes } = require('./capability-manifest');
 
 /**
  * @param {object} doc - Parsed datasource JSON
@@ -16,8 +17,7 @@ const { deepClone } = require('./copy-operations');
  */
 function extractCapabilitySliceForDiff(doc, capabilityKey, profileKey) {
   const cap = capabilityKey;
-  const listed =
-    Boolean(Array.isArray(doc.capabilities) && doc.capabilities.includes(cap));
+  const listed = capabilitiesIncludes(doc.capabilities, cap);
   const openapiOp = doc.openapi?.operations?.[cap];
   const cipOp = doc.execution?.cip?.operations?.[cap];
   let exposedProfile;