@aifabrix/builder 2.50.0 → 2.51.1

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

@@ -27,6 +27,58 @@ function attachUploadAuthToOptions(options, uploadCtx) {
   options.silentResolve = true;
 }
 
+/**
+ * @param {string} key
+ * @param {Object|null} config
+ * @returns {Object}
+ */
+function buildNotApplicableGovernanceRow(key, config) {
+  const {
+    parseAccessControlAbac
+  } = require('../lifecycle/access-control-abac');
+  const abac = parseAccessControlAbac(config);
+  return {
+    datasourceKey: key,
+    verdict: VERDICT.NOT_APPLICABLE,
+    scenarios: { passed: 0, total: 0 },
+    policyCoveragePercent: 100,
+    dimensionCoveragePercent: 100,
+    rationale: abac.rationale
+  };
+}
+
+/**
+ * @param {string} key
+ * @param {Object} ctx
+ * @returns {Promise<Object|null>}
+ */
+async function runRequiredGovernanceDatasource(key, ctx) {
+  try {
+    const packRow = await getDatasourceGovernancePack(ctx.dataplaneUrl, ctx.authConfig, key);
+    if (!packRow || !packRow.pack) {
+      return null;
+    }
+    const result = await runDatasourceGovernanceScenarios(ctx.dataplaneUrl, ctx.authConfig, key);
+    const summary = result.summary || {};
+    return {
+      datasourceKey: key,
+      verdict: summary.failed > 0 ? VERDICT.FAILED : VERDICT.VERIFIED,
+      scenarios: { passed: summary.passed || 0, total: summary.total || 0 },
+      policyCoveragePercent: result.policyCoveragePercent ?? 100,
+      dimensionCoveragePercent: result.dimensionCoveragePercent ?? 100,
+      packDocument: packRow.pack,
+      result
+    };
+  } catch (err) {
+    return {
+      datasourceKey: key,
+      verdict: VERDICT.FAILED,
+      error: err.message,
+      scenarios: { passed: 0, total: 0 }
+    };
+  }
+}
+
 /**
  * @async
  * @param {string[]} keys
@@ -35,35 +87,27 @@ function attachUploadAuthToOptions(options, uploadCtx) {
  * @returns {Promise<Array>}
  */
 async function runGovernanceForDatasourceKeys(keys, ctx, progress = {}) {
+  const {
+    filterAbacRequiredDatasourceKeys,
+    loadDatasourceConfigsByKey
+  } = require('../lifecycle/access-control-abac');
+  const configs = loadDatasourceConfigsByKey(ctx.systemKey || '');
+  const required = new Set(
+    filterAbacRequiredDatasourceKeys(ctx.systemKey || '', keys)
+  );
   const rows = [];
   for (let index = 0; index < keys.length; index += 1) {
     const key = keys[index];
     if (typeof progress.setLabel === 'function') {
       progress.setLabel(`Running governance scenarios: ${key} (${index + 1}/${keys.length})`);
     }
-    try {
-      const packRow = await getDatasourceGovernancePack(ctx.dataplaneUrl, ctx.authConfig, key);
-      if (!packRow || !packRow.pack) {
-        continue;
-      }
-      const result = await runDatasourceGovernanceScenarios(ctx.dataplaneUrl, ctx.authConfig, key);
-      const summary = result.summary || {};
-      rows.push({
-        datasourceKey: key,
-        verdict: summary.failed > 0 ? VERDICT.FAILED : VERDICT.VERIFIED,
-        scenarios: { passed: summary.passed || 0, total: summary.total || 0 },
-        policyCoveragePercent: result.policyCoveragePercent ?? 100,
-        dimensionCoveragePercent: result.dimensionCoveragePercent ?? 100,
-        packDocument: packRow.pack,
-        result
-      });
-    } catch (err) {
-      rows.push({
-        datasourceKey: key,
-        verdict: VERDICT.FAILED,
-        error: err.message,
-        scenarios: { passed: 0, total: 0 }
-      });
+    if (!required.has(key)) {
+      rows.push(buildNotApplicableGovernanceRow(key, configs.get(key) || null));
+      continue;
+    }
+    const row = await runRequiredGovernanceDatasource(key, ctx);
+    if (row) {
+      rows.push(row);
     }
   }
   return rows;
@@ -76,7 +120,12 @@ async function runGovernanceForDatasourceKeys(keys, ctx, progress = {}) {
  * @returns {Promise<Object>}
  */
 async function runVerifyGovernanceFromDbPacks(systemKey, options) {
-  const { systemKey: resolvedKey, keys } = resolveExternalIntegrationContext(systemKey);
+  const { systemKey: resolvedKey, keys: discoveredKeys } =
+    resolveExternalIntegrationContext(systemKey);
+  const keys =
+    Array.isArray(options.datasourceKeys) && options.datasourceKeys.length
+      ? options.datasourceKeys
+      : discoveredKeys;
   if (keys.length === 0) {
     return { resolvedKey, datasourceRows: [] };
   }
@@ -87,10 +136,16 @@ async function runVerifyGovernanceFromDbPacks(systemKey, options) {
   }
 
   const { authConfig, dataplaneUrl } = await resolveIntegrationAuth(resolvedKey, options);
+  options.authConfig = authConfig;
+  options.dataplaneUrl = dataplaneUrl;
   const datasourceRows = await runWithVerifyStepProgress(
     'Running governance scenarios',
     async(progress) =>
-      runGovernanceForDatasourceKeys(keys, { authConfig, dataplaneUrl }, progress),
+      runGovernanceForDatasourceKeys(
+        keys,
+        { authConfig, dataplaneUrl, systemKey: resolvedKey },
+        progress
+      ),
     options
   );
   return { resolvedKey, datasourceRows };

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

@@ -8,7 +8,7 @@
 
 const { runTestGovernanceForExternalSystem } = require('./test-governance-external');
 const { runVerifyGovernanceFromDbPacks } = require('./verify-governance-db');
-const { VERDICT, verdictFromPassed } = require('../lifecycle/product-model');
+const { VERDICT } = require('../lifecycle/product-model');
 const {
   sumEnforcementScenarios,
   aggregateCoverage,
@@ -20,14 +20,26 @@ const {
  * @returns {{ passed: number, total: number }}
  */
 function buildDbPackResult(resolvedKey, datasourceRows) {
-  const allVerified = datasourceRows.every(r => r.verdict === VERDICT.VERIFIED);
+  const hasFailed = datasourceRows.some(r => r.verdict === VERDICT.FAILED);
+  const allNa =
+    datasourceRows.length > 0
+    && datasourceRows.every(r => r.verdict === VERDICT.NOT_APPLICABLE);
+  const allClosed = datasourceRows.every(
+    r => r.verdict === VERDICT.VERIFIED || r.verdict === VERDICT.NOT_APPLICABLE
+  );
+  let verdict = VERDICT.FAILED;
+  if (allNa) {
+    verdict = VERDICT.NOT_APPLICABLE;
+  } else if (allClosed && !hasFailed) {
+    verdict = VERDICT.VERIFIED;
+  }
   const coverage = aggregateCoverage(datasourceRows);
   return {
     systemKey: resolvedKey,
     command: 'verify-governance',
-    verdict: verdictFromPassed(allVerified),
-    policyCoveragePercent: coverage.policy ?? (allVerified ? 100 : 0),
-    dimensionCoveragePercent: coverage.dimension ?? (allVerified ? 100 : 0),
+    verdict,
+    policyCoveragePercent: coverage.policy ?? (allClosed ? 100 : 0),
+    dimensionCoveragePercent: coverage.dimension ?? (allClosed ? 100 : 0),
     enforcementScenarios: sumEnforcementScenarios(datasourceRows),
     datasourceRows
   };
@@ -66,6 +78,18 @@ async function runVerifyGovernanceForExternalSystem(systemKey, options = {}) {
     };
   }
 
+  const naKeys = datasourceRows
+    .filter(row => row.verdict === VERDICT.NOT_APPLICABLE)
+    .map(row => row.datasourceKey)
+    .filter(Boolean);
+  if (naKeys.length > 0 && options.authConfig && options.dataplaneUrl) {
+    const { runSystemLifecycle } = require('../api/lifecycle.api');
+    await runSystemLifecycle(options.dataplaneUrl, options.authConfig, resolvedKey, {
+      steps: ['governance'],
+      datasourceKeys: naKeys
+    });
+  }
+
   return buildDbPackResult(resolvedKey, datasourceRows);
 }
 

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,
-            noPublish: true,
-            verbose: false,
-            debug: options.debug === true
-          }),
-        ok: (result) => result.success === true
-      }
-    ],
-    e2e: {
-      key: 'e2e',
-      run: (progress) =>
-        runTestE2EForExternalSystem(systemKey, {
-          env: options.env,
+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/wizard-core-helpers.js

@@ -232,15 +232,19 @@ function buildPlatformConfigPayload({ credentialIdOrKey, datasourceKeys, configu
 }
 
 /**
- * Extract configuration from API response
+ * Extract configuration from API response.
+ * add-datasource generation returns datasourceConfig(s) only (systemConfig is null by design).
+ * Callers must load the existing workspace system when systemConfig is missing.
  * @param {Object} generateResponse - API response
  * @returns {Object} Extracted configuration
  */
 function extractConfigurationFromResponse(generateResponse) {
-  const systemConfig = generateResponse.data?.systemConfig;
+  const systemConfig = generateResponse.data?.systemConfig || null;
   const datasourceConfigs = generateResponse.data?.datasourceConfigs ||
     (generateResponse.data?.datasourceConfig ? [generateResponse.data.datasourceConfig] : []);
-  if (!systemConfig) throw new Error('System configuration not found');
+  if (!systemConfig && (!Array.isArray(datasourceConfigs) || datasourceConfigs.length === 0)) {
+    throw new Error('System configuration not found');
+  }
   return { systemConfig, datasourceConfigs, systemKey: generateResponse.data?.systemKey };
 }
 

package/lib/commands/wizard-core.js

@@ -312,6 +312,72 @@ async function callGenerateApi(dataplaneUrl, authConfig, options, prefs) {
   return await generateConfig(dataplaneUrl, authConfig, configPayload);
 }
 
+/**
+ * Load existing system JSON/YAML from the integration workspace (add-datasource).
+ * @param {string} appName - Integration app / system key
+ * @returns {Object|null}
+ */
+function loadExistingWorkspaceSystemConfig(appName) {
+  if (!appName || typeof appName !== 'string') {
+    return null;
+  }
+  const { getIntegrationPath } = require('../utils/paths');
+  const { loadConfigFile } = require('../utils/config-format');
+  const fsSync = require('fs');
+  const appPath = getIntegrationPath(appName);
+  for (const ext of ['.json', '.yaml', '.yml']) {
+    const candidate = path.join(appPath, `${appName}-system${ext}`);
+    if (fsSync.existsSync(candidate)) {
+      try {
+        return loadConfigFile(candidate);
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {Object|null|undefined} systemConfig
+ * @param {Object} options
+ * @returns {Object}
+ */
+function resolveSystemConfigForWizardMode(systemConfig, options) {
+  if (systemConfig) {
+    return systemConfig;
+  }
+  if (options.mode === 'add-datasource') {
+    const existing = loadExistingWorkspaceSystemConfig(
+      options.appName || options.systemIdOrKey
+    );
+    if (!existing) {
+      throw new Error(
+        'System configuration not found for add-datasource. ' +
+          'Run create-system wizard first so the workspace has a system file.'
+      );
+    }
+    return existing;
+  }
+  throw new Error('System configuration not found');
+}
+
+/**
+ * @param {Object} generateResponse
+ * @param {Object} prefs
+ * @param {Object} options
+ * @returns {Promise<void>}
+ */
+async function maybeWriteWizardDebugLog(generateResponse, prefs, options) {
+  if (!prefs.debug || !options.appName) {
+    return;
+  }
+  const debugLog = generateResponse.data?.debugLog;
+  if (debugLog && typeof debugLog === 'string') {
+    await writeDebugLog(options.appName, debugLog);
+  }
+}
+
 async function handleConfigurationGeneration(dataplaneUrl, authConfig, options) {
   logger.log(chalk.blue('\n\uD83D\uDCCB Step 5: Generate Configuration'));
   const prefs = buildConfigPreferences(options.configPrefs);
@@ -320,18 +386,21 @@ async function handleConfigurationGeneration(dataplaneUrl, authConfig, options)
     const generateResponse = await callGenerateApi(dataplaneUrl, authConfig, options, prefs);
     spinner.stop();
     if (!generateResponse.success) {
-      await saveDebugManifestOnErrorAndThrow(generateResponse, { enableDebug: prefs.debug, appName: options.appName });
+      await saveDebugManifestOnErrorAndThrow(generateResponse, {
+        enableDebug: prefs.debug,
+        appName: options.appName
+      });
     }
     const result = extractConfigurationFromResponse(generateResponse);
-    const normalized = normalizeWizardConfigs(result.systemConfig, result.datasourceConfigs);
-    if (prefs.debug && options.appName) {
-      const debugLog = generateResponse.data?.debugLog;
-      if (debugLog && typeof debugLog === 'string') {
-        await writeDebugLog(options.appName, debugLog);
-      }
-    }
+    const systemConfig = resolveSystemConfigForWizardMode(result.systemConfig, options);
+    const normalized = normalizeWizardConfigs(systemConfig, result.datasourceConfigs);
+    await maybeWriteWizardDebugLog(generateResponse, prefs, options);
     logger.log(formatSuccessLine('Configuration generated successfully'));
-    return { systemConfig: normalized.systemConfig, datasourceConfigs: normalized.datasourceConfigs, systemKey: result.systemKey };
+    return {
+      systemConfig: normalized.systemConfig,
+      datasourceConfigs: normalized.datasourceConfigs,
+      systemKey: result.systemKey || options.systemIdOrKey || options.appName
+    };
   } catch (error) {
     spinner.stop();
     throw error;

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-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/bulk-loader-run-batches.js

@@ -70,19 +70,21 @@ function recordBatchSuccess(state, index, response, batchRecords) {
  * @returns {Promise<{ batches: Object[], totals: Object }>}
  */
 async function uploadRecordBatches(params) {
-  const { chunks, syncType, dataplaneUrl, datasourceKey, authConfig } = params;
+  const { chunks, syncType, dataplaneUrl, datasourceKey, authConfig, timeoutMs } = params;
   const state = {
     batches: [],
     totals: { insertedCount: 0, updatedCount: 0, failedCount: 0 },
     chunkCount: chunks.length
   };
+  const transportOpts =
+    timeoutMs !== undefined && timeoutMs !== null ? { timeoutMs } : {};
 
   for (let i = 0; i < chunks.length; i += 1) {
     const batchRecords = chunks[i];
     const body = { syncType, sync: false, records: batchRecords };
     try {
       const response = await withTransientRetry(() =>
-        bulkSyncRecords(dataplaneUrl, datasourceKey, authConfig, body)
+        bulkSyncRecords(dataplaneUrl, datasourceKey, authConfig, body, transportOpts)
       );
       recordBatchSuccess(state, i, response, batchRecords);
     } catch (err) {

package/lib/datasource/bulk-loader-service.js

@@ -81,12 +81,16 @@ async function executeDatasourceLoadWork(params) {
     return { ...result, context: ctx };
   }
 
+  const timeoutMs = options.timeoutMs
+    ? parseInt(String(options.timeoutMs), 10)
+    : undefined;
   const { batches, totals } = await uploadRecordBatches({
     chunks: chunkRecords(records, batchSize),
     syncType,
     dataplaneUrl: ctx.dataplaneUrl,
     datasourceKey: ctx.datasourceKey,
-    authConfig: ctx.authConfig
+    authConfig: ctx.authConfig,
+    timeoutMs: Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined
   });
 
   return { ...result, batches, totals, context: ctx };

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/datasource-validate-summary.js

@@ -167,10 +167,10 @@ function assembleSummary(parsed) {
     foreignKeys: fks,
     dimensionKeys,
     dimensions,
-    exposedProfileNames: summarizeExposedProfileNames(parsed),
-    openapiLine: oa.openapiLine,
     hasOpenapi: oa.hasOpenapi,
+    openapiLine: oa.openapiLine,
     capabilityKeys: oa.capabilityKeys,
+    exposedProfileNames: summarizeExposedProfileNames(parsed),
     testPayloadLine: summarizeTestPayloadLine(parsed),
     hasTestPayload: !!parsed.testPayload && typeof parsed.testPayload === 'object',
     syncLine: summarizeSyncLine(sync)

package/lib/datasource/validate.js

@@ -242,9 +242,7 @@ async function validateDatasourceFile(filePathOrKey) {
     };
   }
 
-  const fieldRefErrors = validateFieldReferences(parsed);
-  const abacErrors = validateAbac(parsed);
-  const postSchemaErrors = [...fieldRefErrors, ...abacErrors];
+  const postSchemaErrors = collectPostSchemaErrors(parsed);
   if (postSchemaErrors.length > 0) {
     return {
       valid: false,
@@ -264,6 +262,17 @@ async function validateDatasourceFile(filePathOrKey) {
   };
 }
 
+/**
+ * @param {object} parsed
+ * @returns {string[]}
+ */
+function collectPostSchemaErrors(parsed) {
+  return [
+    ...validateFieldReferences(parsed),
+    ...validateAbac(parsed)
+  ];
+}
+
 /**
  * Validates parsed datasource JSON (same rules as {@link validateDatasourceFile}, without reading a file).
  *
@@ -294,9 +303,7 @@ function validateDatasourceParsed(parsed) {
     };
   }
 
-  const fieldRefErrors = validateFieldReferences(parsed);
-  const abacErrors = validateAbac(parsed);
-  const postSchemaErrors = [...fieldRefErrors, ...abacErrors];
+  const postSchemaErrors = collectPostSchemaErrors(parsed);
   if (postSchemaErrors.length > 0) {
     return {
       valid: false,

package/lib/external-system/deploy-helpers.js

@@ -133,12 +133,46 @@ function extractSystemKey(systemFilePath) {
   return systemFileName.replace(/-deploy$/, '');
 }
 
+/**
+ * Role Assistant (digitalWorker) deploy uses upload, not controller deploy.
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - Deploy options
+ * @param {boolean} compact - Quiet UI when true
+ * @param {Object} manifest - Controller manifest
+ * @returns {Promise<Object|null>} Upload result, or null when not a digital worker
+ */
+async function uploadDigitalWorkerIfNeeded(appName, options, compact, manifest) {
+  const systemKind =
+    manifest && manifest.system && typeof manifest.system.systemKind === 'string'
+      ? manifest.system.systemKind.trim()
+      : '';
+  if (systemKind !== 'digitalWorker') {
+    return null;
+  }
+  if (!compact) {
+    const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
+    const logger = require('../utils/logger');
+    logger.log(
+      formatSuccessParagraph(
+        'Role Assistant deployment uses upload pipeline (controller deploy is skipped).'
+      )
+    );
+  }
+  const { uploadExternalSystem } = require('../commands/upload');
+  return uploadExternalSystem(appName, {
+    ...options,
+    uploadStatus: 'published'
+  });
+}
+
 module.exports = {
   loadVariablesYaml,
   validateSingleSystemFile,
   validateSystemFiles,
   validateSingleDatasourceFile,
   validateDatasourceFiles,
-  extractSystemKey
+  extractSystemKey,
+  uploadDigitalWorkerIfNeeded
 };