@aifabrix/builder 2.52.0 → 2.53.0

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

@@ -7,7 +7,11 @@
  */
 
 const { rewriteCapabilityReferences } = require('./reference-rewrite');
-const { capabilityKeyFromEntry } = require('./capability-manifest');
+const {
+  capabilityKeyFromEntry,
+  capabilitiesIncludes,
+  buildCapabilityObject
+} = require('./capability-manifest');
 const { jsonPointerPath } = require('./json-pointer');
 const { buildBasicExposureProfileArray } = require('./basic-exposure');
 const {
@@ -256,14 +260,20 @@ function appendCapabilityList(doc, resolvedAs, patchOperations, updatedSections)
   if (!Array.isArray(doc.capabilities)) {
     doc.capabilities = [];
   }
-  if (doc.capabilities.includes(resolvedAs)) {
+  if (capabilitiesIncludes(doc.capabilities, resolvedAs)) {
     return;
   }
-  doc.capabilities.push(resolvedAs);
+  const usesObjects = doc.capabilities.some(
+    (entry) => entry && typeof entry === 'object' && !Array.isArray(entry)
+  );
+  const value = usesObjects
+    ? buildCapabilityObject(resolvedAs, doc.displayName || doc.key || 'records')
+    : resolvedAs;
+  doc.capabilities.push(value);
   patchOperations.push({
     op: 'add',
     path: '/capabilities/-',
-    value: resolvedAs
+    value
   });
   updatedSections.push(`capabilities[]: ${resolvedAs}`);
 }

package/lib/deployment/deployer-poll-run.js

@@ -31,7 +31,7 @@ const { createDeployPollHandlers } = require('./deploy-poll-ui');
  */
 async function pollDeploymentStatus(deploymentId, controllerUrl, envKey, authConfig, options = {}) {
   const interval = options.interval || 5000;
-  const maxAttempts = options.maxAttempts || 60;
+  const maxAttempts = options.maxAttempts || 300;
 
   const validatedEnvKey = validateEnvironmentKey(envKey);
   const pipelineAuthConfig = convertToPipelineAuthConfig(authConfig);
@@ -74,7 +74,7 @@ async function pollDeployment(result, url, validatedEnvKey, authConfig, options)
   }
 
   const resolvedInterval = await resolvePollIntervalFromController(url, options.pollInterval);
-  const maxAttempts = options.pollMaxAttempts || 60;
+  const maxAttempts = options.pollMaxAttempts || 300;
   const ownsPollUi = !options.pollUi;
   const pollUi =
     options.pollUi ||

package/lib/deployment/deployer.js

@@ -387,7 +387,7 @@ async function deployToController(manifest, controllerUrl, envKey, authConfig, o
 
   const usePollUi = options.poll !== false && options.silentPoll !== true;
   const pollUi = usePollUi
-    ? createDeployPollHandlers(options.pollMaxAttempts || 60, { silent: false })
+    ? createDeployPollHandlers(options.pollMaxAttempts || 300, { silent: false })
     : null;
   const deployOpts = pollUi ? { ...options, pollUi } : options;
 

package/lib/deployment/environment.js

@@ -253,7 +253,7 @@ async function pollEnvironmentStatus(deploymentId, controllerUrl, envKey, authCo
   const validatedUrl = validateControllerUrl(controllerUrl);
   const validatedEnvKey = validateEnvironmentKey(envKey);
   const pollInterval = options.pollInterval || 5000;
-  const maxAttempts = options.maxAttempts || 60;
+  const maxAttempts = options.maxAttempts || 300;
   const apiAuthConfig = { type: 'bearer', token: authConfig.token };
 
   logger.log(chalk.blue(`⏳ Polling environment status (${pollInterval}ms intervals)...`));
@@ -398,7 +398,7 @@ async function pollDeploymentStatusIfEnabled(result, validatedControllerUrl, env
       authConfig,
       {
         pollInterval,
-        maxAttempts: options.pollMaxAttempts || 60
+        maxAttempts: options.pollMaxAttempts || 300
       }
     );
     result.status = pollResult.status;

package/lib/external-system/deploy.js

@@ -131,19 +131,6 @@ async function fetchDataplaneDeployReadiness(controllerUrl, environment, authCon
   }
 }
 
-/**
- * Deploys via controller and prints readiness summary (config / deployment / runtime layers).
- * @async
- * @param {Object} manifest - Controller manifest
- * @param {string} controllerUrl - Controller base URL
- * @param {string} environment - Environment key
- * @param {Object} authConfig - Authentication configuration
- * @param {Object} options - Deployment options (poll, probe, probeTimeout)
- * @returns {Promise<Object>} Deployment result
- */
-/**
- * @param {Object} deploymentOutcome - from parseControllerDeploymentOutcome
- */
 /**
  * Optional dataplane validation/run after external deploy (--probe).
  * @async
@@ -202,12 +189,21 @@ function logImmediateControllerDeploymentOutcome(deploymentOutcome) {
   logger.log(chalk.gray('   Check the controller deployment job or logs for details.'));
 }
 
+/** External deploy waits on controller → dataplane publish job (may run prove gates / tests). */
+const EXTERNAL_DEPLOY_POLL_INTERVAL_MS = 2000;
+/** 300 × 2s ≈ 10 minutes — must cover controller publish-job max wait with gates. */
+const EXTERNAL_DEPLOY_POLL_MAX_ATTEMPTS = 300;
+
 function buildExternalDeployPollOpts(options) {
   return {
     ...options,
     poll: true,
-    pollInterval: options.pollInterval !== undefined ? options.pollInterval : 500,
-    pollMaxAttempts: options.pollMaxAttempts !== undefined ? options.pollMaxAttempts : 22,
+    pollInterval:
+      options.pollInterval !== undefined ? options.pollInterval : EXTERNAL_DEPLOY_POLL_INTERVAL_MS,
+    pollMaxAttempts:
+      options.pollMaxAttempts !== undefined
+        ? options.pollMaxAttempts
+        : EXTERNAL_DEPLOY_POLL_MAX_ATTEMPTS,
     silentPoll: options.silentPoll === true
   };
 }
@@ -381,12 +377,6 @@ function wrapDeployExternalSystemError(error, appName) {
   return new Error(message);
 }
 
-/**
- * @async
- * @param {string} appName
- * @param {Object} options
- * @returns {Promise<Object>}
- */
 /**
  * @param {string} appName
  * @param {Object} options

package/lib/infrastructure/index.js

@@ -203,12 +203,26 @@ async function removeAppVolumes(appNames, devId) {
   }
 }
 
+/**
+ * Resolve developer id for stop paths. Optional override is transient (not config).
+ * @param {string|number|null|undefined} developerId
+ * @returns {Promise<string>}
+ */
+async function resolveStopDeveloperId(developerId) {
+  if (developerId === undefined || developerId === null || developerId === '') {
+    return config.getDeveloperId();
+  }
+  const { validateAndNormalizeDeveloperId } = require('../core/config-normalize');
+  return validateAndNormalizeDeveloperId(developerId);
+}
+
 /**
  * Stops and removes local infrastructure services and all application containers
  * on the same network. Cleanly shuts down infra and app containers.
  *
  * @async
  * @function stopInfra
+ * @param {string|number|null|undefined} [developerId] - Optional target developer (does not change config)
  * @returns {Promise<void>} Resolves when infrastructure is stopped
  * @throws {Error} If Docker compose fails
  *
@@ -216,8 +230,8 @@ async function removeAppVolumes(appNames, devId) {
  * await stopInfra();
  * // All infrastructure and app containers on the same network are stopped and removed
  */
-async function stopInfra() {
-  const devId = await config.getDeveloperId();
+async function stopInfra(developerId) {
+  const devId = await resolveStopDeveloperId(developerId);
   const { infraDir, adminSecretsPath } = resolveInfraStatePaths(devId);
   const composePath = path.join(infraDir, 'compose.yaml');
   const hasCompose = fs.existsSync(composePath);
@@ -279,6 +293,7 @@ async function stopAllAppContainersAndVolumes(devId) {
  *
  * @async
  * @function stopInfraWithVolumes
+ * @param {string|number|null|undefined} [developerId] - Optional target developer (does not change config)
  * @returns {Promise<void>} Resolves when infrastructure is stopped and volumes removed
  * @throws {Error} If Docker compose fails
  *
@@ -286,8 +301,8 @@ async function stopAllAppContainersAndVolumes(devId) {
  * await stopInfraWithVolumes();
  * // All infrastructure and app containers and volumes are removed
  */
-async function stopInfraWithVolumes() {
-  const devId = await config.getDeveloperId();
+async function stopInfraWithVolumes(developerId) {
+  const devId = await resolveStopDeveloperId(developerId);
   const { infraDir, adminSecretsPath } = resolveInfraStatePaths(devId);
   const composePath = path.join(infraDir, 'compose.yaml');
   const hasCompose = fs.existsSync(composePath);

package/lib/integration-definition/apply.js

@@ -0,0 +1,476 @@
+/**
+ * Apply Builder Integration Definition to integration/<systemKey>/.
+ * @fileoverview Idempotent BID → package materialization (no AI)
+ */
+
+'use strict';
+
+const path = require('path');
+const fsReal = require('../internal/fs-real-sync');
+const { getIntegrationPath } = require('../utils/paths');
+const { validateIntegrationDefinition } = require('./validate');
+
+const STAMP_FILE = '.aifabrix-integration-definition.json';
+
+/**
+ * @param {string} dir
+ * @returns {Promise<Record<string, unknown> | null>}
+ */
+async function readStamp(dir) {
+  const stampPath = path.join(dir, STAMP_FILE);
+  try {
+    const raw = fsReal.readFileSync(stampPath, 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      return null;
+    }
+    throw err;
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} bid
+ * @param {Record<string, unknown>} stamp
+ * @returns {void}
+ */
+function assertApplyAllowed(bid, stamp) {
+  if (!stamp) {
+    return;
+  }
+  const meta = /** @type {Record<string, unknown>} */ (bid.meta || {});
+  if (stamp.definitionId === bid.definitionId && stamp.definitionHash === bid.definitionHash) {
+    return;
+  }
+  if (stamp.definitionId === bid.definitionId) {
+    return;
+  }
+  if (stamp.systemKey === /** @type {any} */ (bid.packageIdentity).systemKey && !meta.replaceSystemKey) {
+    const err = new Error(
+      `systemKey ${stamp.systemKey} already bound to definitionId ${stamp.definitionId}; ` +
+        'set meta.replaceSystemKey true to replace'
+    );
+    err.code = 'BID_SYSTEM_KEY_CONFLICT';
+    throw err;
+  }
+}
+
+function buildDatasourceCapabilities(caps, key) {
+  return caps.map((capability) => ({
+    key: capability,
+    description: `${capability} ${key}`,
+    riskLevel:
+      capability === 'delete'
+        ? 'high'
+        : capability.startsWith('create') || capability.startsWith('update')
+          ? 'medium'
+          : 'low',
+    approvalRequired: false
+  }));
+}
+
+function buildDatasourceSchema(labelField) {
+  return {
+    metadataSchema: {
+      type: 'object',
+      properties: {
+        externalId: { type: 'string', index: true, description: 'Stable external join identity' },
+        id: { type: 'string', index: true, description: 'Vendor record id' },
+        [labelField]: { type: 'string', index: true, filter: true, description: 'Display label' }
+      },
+      required: ['externalId', 'id']
+    },
+    fieldMappings: {
+      attributes: {
+        id: { expression: '{{raw.id}}', description: 'Vendor record id' },
+        externalId: {
+          expression: '{{raw.id}}',
+          description: 'Stable join identity (defaults to vendor id until enrichment)'
+        },
+        [labelField]: {
+          expression: `{{raw.${labelField}}}`,
+          description: 'Display label (enrich from OpenAPI raw paths as needed)'
+        }
+      }
+    }
+  };
+}
+
+function enrichDatasourceFile(body, ds, enrichOptions) {
+  const { enrichDatasourceFromOpenApi } = require('./enrich-openapi-operations');
+  const openapiSourceRef =
+    (typeof ds.openapiSourceRef === 'string' && ds.openapiSourceRef.trim()) ||
+    (typeof enrichOptions.systemOpenapiSourceRef === 'string' &&
+      enrichOptions.systemOpenapiSourceRef.trim()) ||
+    '';
+  if (openapiSourceRef) {
+    enrichDatasourceFromOpenApi(body, openapiSourceRef, {
+      baseDir: enrichOptions.baseDir,
+      associationTargets: enrichOptions.associationTargets
+    });
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} ds
+ * @param {string} systemKey
+ * @param {Record<string, string[]>} capabilities
+ * @param {Record<string, unknown>} sync
+ * @returns {Record<string, unknown>}
+ */
+function buildDatasourceFile(ds, systemKey, capabilities, sync, enrichOptions = {}) {
+  const key = String(ds.key);
+  const caps = capabilities[key] || ds.capabilityKeys || ['list', 'get'];
+  const labelField = ds.labelField || 'name';
+  const { repairSyncOperationsFromCapabilities } = require('../commands/repair-datasource-sync-operations');
+  const { seedPropertyKeysOnDatasource } = require('./enrich-crm-field-mappings');
+  const body = {
+    key,
+    displayName: ds.displayName || key,
+    description: ds.description || `${ds.displayName || key} datasource`,
+    enabled: true,
+    systemKey,
+    entityType: ds.entityType || 'recordStorage',
+    resourceType: ds.resourceType,
+    version: '1.0.0',
+    capabilities: buildDatasourceCapabilities(caps, key),
+    // Schema sync is mode/schedule/batchSize only; BID sync.mode=incremental is operational intent.
+    sync: { mode: 'pull', schedule: /** @type {any} */ (sync).schedule || '0 */6 * * *', batchSize: 100 },
+    primaryKey: ['id'],
+    labelKey: [labelField],
+    ...buildDatasourceSchema(labelField)
+  };
+    // Mirror capabilities → openapi.operations + execution.cip.operations stubs (154.7).
+  repairSyncOperationsFromCapabilities(body, []);
+  seedPropertyKeysOnDatasource(body, ds.propertyKeys);
+  enrichDatasourceFile(body, ds, enrichOptions);
+  return body;
+}
+
+/**
+ * Collect vendor object-type segments from each datasource OpenAPI ref.
+ * Used so list/get can request associations to sibling collections.
+ * @param {any[]} datasources
+ * @param {string} systemOpenapiSourceRef
+ * @param {{ baseDir?: string }} enrichOptions
+ * @returns {string[]}
+ */
+function collectAssociationObjectTypes(datasources, systemOpenapiSourceRef, enrichOptions = {}) {
+  const {
+    loadOpenApiDocument,
+    indexOpenApiOperations,
+    objectTypeFromOpenApiPath
+  } = require('./enrich-openapi-operations');
+  const types = new Set();
+  for (const ds of datasources || []) {
+    // BID datasource keys are the named collection segments CRM association
+    // queries expect (opaque OpenAPI paths like /objects/0-3 omit these).
+    const dsKey = String(ds.key || '').trim();
+    if (dsKey) {
+      types.add(dsKey);
+    }
+    const ref =
+      (typeof ds.openapiSourceRef === 'string' && ds.openapiSourceRef.trim()) ||
+      systemOpenapiSourceRef ||
+      '';
+    if (!ref) {
+      continue;
+    }
+    try {
+      const doc = loadOpenApiDocument(ref, enrichOptions.baseDir);
+      const ops = indexOpenApiOperations(doc);
+      for (const op of ops) {
+        const objectType = objectTypeFromOpenApiPath(op.path);
+        if (objectType) {
+          types.add(objectType);
+        }
+      }
+    } catch {
+      // Skip unreadable refs; enrichment still binds per-datasource.
+    }
+  }
+  return [...types];
+}
+
+/**
+ * @param {Record<string, unknown>} bid
+ * @returns {Record<string, unknown>}
+ */
+function buildSystemFile(bid) {
+  const system = /** @type {Record<string, unknown>} */ (bid.system);
+  const identity = /** @type {Record<string, unknown>} */ (bid.packageIdentity);
+  const refs = /** @type {Record<string, string>} */ (system.connectionRefs || {});
+  const tokenRef = refs.token || refs.apiKey || Object.values(refs)[0] || `kv://${identity.systemKey}/token`;
+  return {
+    key: system.key,
+    displayName: system.displayName || identity.displayName,
+    description: system.description || identity.displayName,
+    type: system.type || 'openapi',
+    enabled: true,
+    systemKind: system.systemKind || 'crm',
+    authentication: {
+      authType: 'credential',
+      credential: {
+        credentialKey: `${identity.systemKey}-cred`,
+        method: 'bearerToken',
+        variables: {
+          baseUrl: refs.baseUrl || 'https://example.invalid',
+          headerName: 'Authorization',
+          prefix: 'Bearer'
+        },
+        security: {
+          token: tokenRef
+        },
+        writeOnce: true
+      }
+    },
+    dataSources: (/** @type {any[]} */ (bid.datasources) || []).map((d) => d.key)
+  };
+}
+
+/**
+ * @param {Record<string, unknown>} bid
+ * @param {string[]} datasourceFiles
+ * @param {string} systemFile
+ * @returns {Record<string, unknown>}
+ */
+function buildApplicationFile(bid, datasourceFiles, systemFile) {
+  const identity = /** @type {Record<string, unknown>} */ (bid.packageIdentity);
+  return {
+    app: {
+      key: identity.systemKey,
+      displayName: identity.displayName,
+      description: `${identity.displayName} (BT BID-applied)`,
+      type: 'external'
+    },
+    externalIntegration: {
+      schemaBasePath: './',
+      systems: [systemFile],
+      dataSources: datasourceFiles,
+      autopublish: true,
+      version: identity.packageVersion
+    },
+    integrationDefinition: {
+      schemaName: bid.schemaName,
+      schemaVersion: bid.schemaVersion,
+      definitionId: bid.definitionId,
+      definitionHash: bid.definitionHash,
+      suiteRunId: /** @type {any} */ (bid.meta).suiteRunId
+    }
+  };
+}
+
+/**
+ * @param {Record<string, unknown>} bid
+ * @returns {string}
+ */
+function buildEnvTemplate(bid) {
+  const identity = /** @type {Record<string, unknown>} */ (bid.packageIdentity);
+  const systemKey = String(identity.systemKey);
+  const system = /** @type {Record<string, unknown>} */ (bid.system || {});
+  const refs = /** @type {Record<string, string>} */ (system.connectionRefs || {});
+  const tokenRef = refs.token || refs.apiKey || `kv://${systemKey}/token`;
+  return [
+    `# Environment for ${systemKey} (BID-applied). No plaintext secrets.`,
+    `# Resolve with aifabrix secret set ${systemKey}/token "<value>" --shared`,
+    `KV_TOKEN=${tokenRef}`,
+    ''
+  ].join('\n');
+}
+
+/**
+ * @param {Record<string, unknown>} bid
+ * @param {string} systemKey
+ * @returns {{
+ *   systemFile: string,
+ *   datasourceFiles: string[],
+ *   application: Record<string, unknown>,
+ *   system: Record<string, unknown>,
+ *   dsFiles: Array<{ name: string, body: Record<string, unknown> }>,
+ *   nextStamp: Record<string, unknown>
+ * }}
+ */
+function buildPackageArtifacts(bid, systemKey, enrichOptions = {}) {
+  const identity = /** @type {Record<string, unknown>} */ (bid.packageIdentity);
+  const datasources = /** @type {Record<string, unknown>[]} */ (bid.datasources || []);
+  const capabilities = /** @type {Record<string, string[]>} */ (bid.capabilities || {});
+  const sync = /** @type {Record<string, unknown>} */ (bid.sync || {});
+  const system = /** @type {Record<string, unknown>} */ (bid.system || {});
+  const systemOpenapiSourceRef =
+    typeof system.openapiSourceRef === 'string' ? system.openapiSourceRef : '';
+  const associationTargets = collectAssociationObjectTypes(
+    datasources,
+    systemOpenapiSourceRef,
+    enrichOptions
+  );
+  const systemFile = `${systemKey}-system.json`;
+  const datasourceFiles = datasources.map((ds) => `${systemKey}-datasource-${ds.key}.json`);
+  return {
+    systemFile,
+    datasourceFiles,
+    application: buildApplicationFile(bid, datasourceFiles, systemFile),
+    system: buildSystemFile(bid),
+    dsFiles: datasources.map((ds) => ({
+      name: `${systemKey}-datasource-${ds.key}.json`,
+      body: buildDatasourceFile(ds, systemKey, capabilities, sync, {
+        ...enrichOptions,
+        systemOpenapiSourceRef,
+        associationTargets
+      })
+    })),
+    envTemplate: buildEnvTemplate(bid),
+    nextStamp: {
+      schemaName: bid.schemaName,
+      schemaVersion: bid.schemaVersion,
+      definitionId: bid.definitionId,
+      definitionHash: bid.definitionHash,
+      suiteRunId: /** @type {any} */ (bid.meta).suiteRunId,
+      systemKey,
+      packageVersion: identity.packageVersion,
+      appliedAt: new Date().toISOString()
+    }
+  };
+}
+
+/**
+ * @param {string} outDir
+ * @param {ReturnType<typeof buildPackageArtifacts>} artifacts
+ * @returns {Promise<void>}
+ */
+async function writePackageArtifacts(outDir, artifacts) {
+  fsReal.mkdirSync(outDir, { recursive: true });
+  fsReal.writeFileSync(
+    path.join(outDir, 'application.json'),
+    JSON.stringify(artifacts.application, null, 2),
+    'utf8'
+  );
+  fsReal.writeFileSync(
+    path.join(outDir, artifacts.systemFile),
+    JSON.stringify(artifacts.system, null, 2),
+    'utf8'
+  );
+  for (const file of artifacts.dsFiles) {
+    fsReal.writeFileSync(path.join(outDir, file.name), JSON.stringify(file.body, null, 2), 'utf8');
+  }
+  fsReal.writeFileSync(path.join(outDir, 'env.template'), artifacts.envTemplate, 'utf8');
+  fsReal.writeFileSync(
+    path.join(outDir, STAMP_FILE),
+    JSON.stringify(artifacts.nextStamp, null, 2),
+    'utf8'
+  );
+}
+
+/**
+ * @param {unknown} bidInput
+ * @returns {Record<string, unknown>}
+ */
+function requireValidBid(bidInput) {
+  const result = validateIntegrationDefinition(bidInput);
+  if (!result.valid) {
+    const err = new Error(`Invalid BID: ${result.errors.join('; ')}`);
+    err.code = 'BID_INVALID';
+    err.errors = result.errors;
+    throw err;
+  }
+  return result.bid;
+}
+
+/**
+ * @param {Record<string, unknown> | null} stamp
+ * @param {Record<string, unknown>} bid
+ * @param {string} outDir
+ * @param {string} systemKey
+ * @returns {Record<string, unknown> | null}
+ */
+function idempotentResult(stamp, bid, outDir, systemKey) {
+  const identity = /** @type {Record<string, unknown>} */ (bid.packageIdentity);
+  if (
+    !(
+      stamp &&
+      stamp.definitionId === bid.definitionId &&
+      stamp.definitionHash === bid.definitionHash &&
+      fsReal.existsSync(path.join(outDir, 'application.json'))
+    )
+  ) {
+    return null;
+  }
+  return {
+    status: 'idempotent',
+    systemKey,
+    outputDir: outDir,
+    definitionId: bid.definitionId,
+    definitionHash: bid.definitionHash,
+    packageVersion: identity.packageVersion
+  };
+}
+
+/**
+ * Apply a validated BID to the integration workspace.
+ * @async
+ * @param {Record<string, unknown>} bidInput
+ * @param {{
+ *   outputDir?: string,
+ *   workspaceRoot?: string,
+ *   dryRun?: boolean,
+ *   force?: boolean,
+ *   openapiBaseDir?: string,
+ *   baseDir?: string
+ * }} [options]
+ * @returns {Promise<Record<string, unknown>>}
+ */
+async function applyIntegrationDefinition(bidInput, options = {}) {
+  const bid = requireValidBid(bidInput);
+  const identity = /** @type {Record<string, unknown>} */ (bid.packageIdentity);
+  const systemKey = String(identity.systemKey);
+  const outDir =
+    options.outputDir ||
+    (options.workspaceRoot
+      ? path.join(options.workspaceRoot, 'integration', systemKey)
+      : getIntegrationPath(systemKey));
+  const stamp = await readStamp(outDir);
+  const early = options.force ? null : idempotentResult(stamp, bid, outDir, systemKey);
+  if (early) {
+    return early;
+  }
+  assertApplyAllowed(bid, stamp);
+  // Prefer explicit openapiBaseDir (workspace integration/<systemKey>/openapi
+  // from 517.2 persist). Do not default product apply to ship-local enrichment.
+  const artifacts = buildPackageArtifacts(bid, systemKey, {
+    baseDir: options.openapiBaseDir || options.baseDir
+  });
+  const fileList = [
+    'application.json',
+    artifacts.systemFile,
+    ...artifacts.datasourceFiles,
+    'env.template',
+    STAMP_FILE
+  ];
+  if (options.dryRun) {
+    return {
+      status: 'dryRun',
+      systemKey,
+      outputDir: outDir,
+      files: fileList,
+      stamp: artifacts.nextStamp
+    };
+  }
+  await writePackageArtifacts(outDir, artifacts);
+  return {
+    status: stamp ? 'updated' : 'created',
+    systemKey,
+    outputDir: outDir,
+    definitionId: bid.definitionId,
+    definitionHash: bid.definitionHash,
+    packageVersion: identity.packageVersion,
+    files: fileList
+  };
+}
+
+module.exports = {
+  applyIntegrationDefinition,
+  STAMP_FILE,
+  buildApplicationFile,
+  buildSystemFile,
+  buildDatasourceFile,
+  buildEnvTemplate
+};