@aifabrix/builder 2.52.1 → 2.53.1

package/lib/programmatic/persist-supplied-openapi.js

@@ -0,0 +1,180 @@
+/**
+ * Persist validated OpenAPI documents into workspace openapi/ (517.2).
+ * @fileoverview Runtime-authorized documents only — Builder never browses task store
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const path = require('path');
+const fs = require('../internal/fs-real-sync');
+const { assertValidSystemKey } = require('./system-key');
+const { ensureIntegrationDirectory } = require('./workspace-context');
+
+function sha256Hex(buffer) {
+  return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+function safeOpenApiBasename(filename) {
+  const raw = String(filename || '').trim();
+  const base = path.basename(raw);
+  if (!base || base === '.' || base === '..') {
+    throw new Error('openapi.filename.invalid');
+  }
+  if (raw.includes('..') || raw.includes('/') || raw.includes('\\') || raw.includes('\0')) {
+    throw new Error('openapi.filename.pathTraversal');
+  }
+  return base.endsWith('.json') || base.endsWith('.yaml') || base.endsWith('.yml')
+    ? base
+    : `${base}.json`;
+}
+
+function parseOpenApiDocument(body) {
+  if (body && typeof body === 'object' && !Array.isArray(body)) {
+    return body;
+  }
+  if (typeof body === 'string') {
+    const trimmed = body.trim();
+    if (!trimmed) {
+      throw new Error('openapi.empty');
+    }
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+      return JSON.parse(trimmed);
+    }
+    throw new Error('openapi.yamlUnsupportedInSliceB');
+  }
+  throw new Error('openapi.body.required');
+}
+
+function validateOpenApiDocument(doc) {
+  if (!doc || typeof doc !== 'object' || Array.isArray(doc)) {
+    return { ok: false, reason: 'openapi.invalid', detail: 'Document must be an object' };
+  }
+  const version = typeof doc.openapi === 'string' ? doc.openapi.trim() : '';
+  if (!/^3\./.test(version)) {
+    return {
+      ok: false,
+      reason: 'openapi.invalid',
+      detail: 'Top-level openapi must be a 3.x string'
+    };
+  }
+  if (!doc.paths || typeof doc.paths !== 'object' || Array.isArray(doc.paths)) {
+    return {
+      ok: false,
+      reason: 'openapi.invalid',
+      detail: 'paths object is required'
+    };
+  }
+  if (Object.keys(doc.paths).length === 0) {
+    return {
+      ok: false,
+      reason: 'openapi.invalid',
+      detail: 'paths must not be empty for persist'
+    };
+  }
+  return { ok: true };
+}
+
+function documentBytes(doc) {
+  return Buffer.from(`${JSON.stringify(doc, null, 2)}\n`, 'utf8');
+}
+
+function openapiDirForContext(ctx) {
+  ensureIntegrationDirectory(ctx);
+  return path.join(ctx.getIntegrationRoot(), ctx.systemKey, 'openapi');
+}
+
+function relativeWorkspacePath(ctx, absolutePath) {
+  const root = ctx.getIntegrationRoot();
+  const rel = path.relative(root, absolutePath);
+  // root is .../integration; rel already includes <systemKey>/openapi/<file>
+  return path.join('integration', rel).split(path.sep).join('/');
+}
+
+function persistOneDocument(ctx, row) {
+  let filename = 'unknown.json';
+  try {
+    filename = safeOpenApiBasename(row && (row.filename || row.name));
+  } catch (error) {
+    return {
+      rejected: {
+        filename: String((row && (row.filename || row.name)) || 'unknown'),
+        reason: 'openapi.filename.invalid',
+        detail: error.message || String(error)
+      }
+    };
+  }
+  let doc;
+  try {
+    doc = parseOpenApiDocument(row && row.body);
+  } catch (error) {
+    return {
+      rejected: {
+        filename,
+        reason: 'openapi.invalid',
+        detail: error.message || String(error)
+      }
+    };
+  }
+  const check = validateOpenApiDocument(doc);
+  if (!check.ok) {
+    return { rejected: { filename, reason: check.reason, detail: check.detail } };
+  }
+  const bytes = documentBytes(doc);
+  const digest = `sha256:${sha256Hex(bytes)}`;
+  if (row.digest && String(row.digest).trim() && String(row.digest).trim() !== digest) {
+    return {
+      rejected: {
+        filename,
+        reason: 'openapi.digestMismatch',
+        detail: 'Provided digest does not match serialized body'
+      }
+    };
+  }
+  const dir = openapiDirForContext(ctx);
+  fs.mkdirSync(dir, { recursive: true });
+  const absolutePath = path.join(dir, filename);
+  fs.writeFileSync(absolutePath, bytes);
+  return {
+    accepted: {
+      filename,
+      path: relativeWorkspacePath(ctx, absolutePath),
+      digest
+    }
+  };
+}
+
+/**
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @param {Object} body
+ * @returns {{ accepted: Object[], rejected: Object[], workspaceRoot: string }}
+ */
+function persistSuppliedOpenApi(ctx, body) {
+  assertValidSystemKey(ctx.systemKey);
+  const documents = body && Array.isArray(body.documents) ? body.documents : null;
+  if (!documents || documents.length === 0) {
+    throw new Error('documents array is required');
+  }
+  const accepted = [];
+  const rejected = [];
+  for (const row of documents) {
+    const outcome = persistOneDocument(ctx, row);
+    if (outcome.accepted) {
+      accepted.push(outcome.accepted);
+    } else if (outcome.rejected) {
+      rejected.push(outcome.rejected);
+    }
+  }
+  return {
+    accepted,
+    rejected,
+    workspaceRoot: ctx.getIntegrationRoot()
+  };
+}
+
+module.exports = {
+  persistSuppliedOpenApi,
+  validateOpenApiDocument,
+  safeOpenApiBasename,
+  parseOpenApiDocument
+};

package/lib/programmatic/route-handler-map.js

@@ -10,6 +10,7 @@
 
 const { buildContext } = require('./route-handlers-context');
 const { listSystems, createSystem, getSystemManifest, deleteSystem } = require('./workspace-ops');
+const { persistSuppliedOpenApi } = require('./persist-supplied-openapi');
 const { runWizard } = require('./run-wizard');
 const {
   applyIntegrationDefinitionInWorkspace
@@ -63,6 +64,11 @@ const HANDLER_MAP = {
     }
     return createSystem(buildContext(auth, key), key);
   },
+  persistSuppliedOpenApi: (params, auth, body) =>
+    persistSuppliedOpenApi(
+      buildContext(auth, params.systemKey),
+      body && typeof body === 'object' ? body : {}
+    ),
   getSystemManifest: (params, auth) => getSystemManifest(buildContext(auth, params.systemKey)),
   deleteSystem: (params, auth) => deleteSystem(buildContext(auth, params.systemKey)),
   runWizard: (params, auth, body, query) =>

package/lib/programmatic/run-integration-definition.js

@@ -9,6 +9,7 @@
 'use strict';
 
 const path = require('path');
+const fs = require('../internal/fs-real-sync');
 const {
   applyIntegrationDefinition,
   withDefinitionHash
@@ -20,10 +21,17 @@ const {
 } = require('./workspace-context');
 const { touchWorkspaceMeta } = require('./workspace-meta');
 
-const OPENAPI_ENRICHMENT_DIR = path.join(
-  __dirname,
-  '../integration-definition/openapi-enrichment'
-);
+/**
+ * Workspace openapi/ is the only product resolve root for BID openapiSourceRef
+ * (517.2 persist layout). Do not bind apply to ship-local enrichment fixtures.
+ * @param {import('./workspace-context').WorkspaceContext} ctx
+ * @returns {string}
+ */
+function workspaceOpenApiBaseDir(ctx) {
+  const dir = path.join(ctx.getIntegrationPath(), 'openapi');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
 
 /**
  * @param {import('./workspace-context').WorkspaceContext} ctx
@@ -54,7 +62,7 @@ async function applyIntegrationDefinitionInWorkspace(ctx, body = {}) {
       outputDir: ctx.getIntegrationPath(),
       force,
       dryRun,
-      openapiBaseDir: OPENAPI_ENRICHMENT_DIR
+      openapiBaseDir: workspaceOpenApiBaseDir(ctx)
     });
     touchWorkspaceMeta(ctx, {
       lastOperation: 'integration-definition-apply',

package/lib/role-assistant/evidence-sync.js

@@ -27,6 +27,10 @@ const EVIDENCE_DIR_NAME = 'evidence';
 const EVIDENCE_EXPORT_FILE = 'evidence.json';
 const VALIDATION_FAILED = 'failed';
 const VALIDATION_PASSED = 'passed';
+/** Builder-keyed Category B catalogue — never import as Evidence (517.3 / 517.4.1). */
+const SKIP_EVIDENCE_BASENAMES = new Set(['capability-business-catalog.json']);
+/** PoC draft folders under evidence/ — never import as governed Evidence. */
+const SKIP_EVIDENCE_DIR_NAMES = new Set(['candidates', 'candidate']);
 
 const EVIDENCE_MUTABLE_KEYS = [
   'key',
@@ -79,6 +83,23 @@ function isEvidenceFileName(fileName) {
   return lower.endsWith('.json') || lower.endsWith('.yaml') || lower.endsWith('.yml');
 }
 
+/**
+ * Skip retired / forbidden evidence payloads (517.4.1 scrub).
+ * @param {string} filePath
+ * @param {unknown} parsed
+ * @returns {boolean}
+ */
+function shouldSkipEvidencePayload(filePath, parsed) {
+  const base = path.basename(String(filePath || '')).toLowerCase();
+  if (SKIP_EVIDENCE_BASENAMES.has(base)) {
+    return true;
+  }
+  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && parsed._retired === true) {
+    return true;
+  }
+  return false;
+}
+
 function collectEvidenceFiles(dirPath) {
   if (!fs.existsSync(dirPath)) {
     return [];
@@ -88,6 +109,10 @@ function collectEvidenceFiles(dirPath) {
   for (const entry of entries) {
     const fullPath = path.join(dirPath, entry.name);
     if (entry.isDirectory()) {
+      const dirName = String(entry.name || '').trim().toLowerCase();
+      if (SKIP_EVIDENCE_DIR_NAMES.has(dirName)) {
+        continue;
+      }
       files.push(...collectEvidenceFiles(fullPath));
       continue;
     }
@@ -152,8 +177,13 @@ function sanitizeEvidenceRow(row, systemKey, options = {}) {
 function loadEvidenceRowsFromFolder(evidencePath, systemKey) {
   const files = collectEvidenceFiles(evidencePath);
   const rows = [];
+  const skippedFiles = [];
   for (const filePath of files) {
     const parsed = parseEvidenceFile(filePath);
+    if (shouldSkipEvidencePayload(filePath, parsed)) {
+      skippedFiles.push(path.relative(evidencePath, filePath));
+      continue;
+    }
     const extractedRows = extractEvidenceRows(parsed);
     for (const row of extractedRows) {
       if (!row || typeof row !== 'object' || Array.isArray(row)) {
@@ -169,7 +199,7 @@ function loadEvidenceRowsFromFolder(evidencePath, systemKey) {
       rows.push(normalized);
     }
   }
-  return { files, rows };
+  return { files, rows, skippedFiles };
 }
 
 function resolveEvidenceDirectory(systemKey, pathOptions = {}) {
@@ -277,21 +307,25 @@ function buildFailureSummary(failures) {
   return `${preview}${more}`;
 }
 
-function buildEvidenceDryRunSummary(evidencePath, files, rows) {
+function buildEvidenceDryRunSummary(evidencePath, files, rows, skippedFiles = []) {
   return {
     skipped: false,
     dryRun: true,
     evidencePath,
     filesDiscovered: files.length,
+    filesSkipped: skippedFiles.length,
+    skippedFiles: [...skippedFiles],
     discovered: rows.length
   };
 }
 
-function buildEvidenceImportSummary(evidencePath, files, rows, loadResult) {
+function buildEvidenceImportSummary(evidencePath, files, rows, loadResult, skippedFiles = []) {
   return {
     skipped: false,
     evidencePath,
     filesDiscovered: files.length,
+    filesSkipped: skippedFiles.length,
+    skippedFiles: [...skippedFiles],
     discovered: rows.length,
     loaded: Number(loadResult.inserted || 0) + Number(loadResult.updated || 0),
     validated: 0,
@@ -347,12 +381,18 @@ async function importRoleAssistantEvidence(params) {
     return { skipped: true, reason: 'not-role-assistant' };
   }
   const evidencePath = resolveEvidenceDirectory(systemKey, pathOptions);
-  const { files, rows } = loadEvidenceRowsFromFolder(evidencePath, systemKey);
+  const { files, rows, skippedFiles } = loadEvidenceRowsFromFolder(evidencePath, systemKey);
   if (rows.length === 0) {
-    return { skipped: true, reason: 'no-evidence-files', evidencePath };
+    return {
+      skipped: true,
+      reason: 'no-evidence-files',
+      evidencePath,
+      filesSkipped: (skippedFiles || []).length,
+      skippedFiles: [...(skippedFiles || [])]
+    };
   }
   if (dryRun) {
-    return buildEvidenceDryRunSummary(evidencePath, files, rows);
+    return buildEvidenceDryRunSummary(evidencePath, files, rows, skippedFiles);
   }
   const { loadResult, refs } = await loadEvidenceAndResolveRefs(
     dataplaneUrl,
@@ -360,7 +400,13 @@ async function importRoleAssistantEvidence(params) {
     systemKey,
     rows
   );
-  const summary = buildEvidenceImportSummary(evidencePath, files, rows, loadResult);
+  const summary = buildEvidenceImportSummary(
+    evidencePath,
+    files,
+    rows,
+    loadResult,
+    skippedFiles
+  );
   const failures = await runEvidenceLifecycleBatch(dataplaneUrl, authConfig, refs, summary);
   appendUnresolvedEvidenceFailures(summary, failures, refs.length, rows.length);
   throwWhenEvidenceLifecycleFailed(summary, failures);
@@ -443,6 +489,8 @@ function logRoleAssistantEvidenceExportSummary(systemKey, result, options = {})
 
 module.exports = {
   isDigitalWorkerModel,
+  shouldSkipEvidencePayload,
+  loadEvidenceRowsFromFolder,
   importRoleAssistantEvidence,
   exportRoleAssistantEvidence,
   logRoleAssistantEvidenceImportSummary,

package/lib/role-assistant/test-runner-attachments.js

@@ -0,0 +1,118 @@
+/**
+ * Build work.start attachments from case YAML (paths / openapiDir).
+ * @fileoverview 517.1 — map suite OpenAPI files to ATT attachment shape
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('../internal/fs-real-sync');
+
+function resolveCaseDirectory(testCase) {
+  const sourceFile =
+    testCase && typeof testCase.sourceFile === 'string' ? testCase.sourceFile.trim() : '';
+  if (!sourceFile) {
+    return process.cwd();
+  }
+  return path.dirname(path.resolve(sourceFile));
+}
+
+function readJsonAttachmentBody(absolutePath) {
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Role assistant attachment file not found: ${absolutePath}`);
+  }
+  const text = fs.readFileSync(absolutePath, 'utf8');
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Role assistant attachment is not valid JSON: ${absolutePath}`);
+  }
+}
+
+function attachmentFromFile(absolutePath, meta = {}) {
+  const basename = path.basename(absolutePath);
+  const role = typeof meta.role === 'string' && meta.role.trim() ? meta.role.trim() : 'openapi';
+  return {
+    name: basename,
+    filename: basename,
+    mediaType: 'application/json',
+    role,
+    contributionPurpose: 'task',
+    body: readJsonAttachmentBody(absolutePath)
+  };
+}
+
+function resolveRelativeAttachmentPath(caseDir, relativePath) {
+  if (typeof relativePath !== 'string' || !relativePath.trim()) {
+    throw new Error('Role assistant attachment path must be a non-empty string');
+  }
+  const absolutePath = path.resolve(caseDir, relativePath.trim());
+  return absolutePath;
+}
+
+function collectExplicitAttachments(caseDir, attachments) {
+  if (!Array.isArray(attachments) || attachments.length === 0) {
+    return [];
+  }
+  return attachments.map((row) => {
+    if (!row || typeof row !== 'object' || Array.isArray(row)) {
+      throw new Error('Role assistant input.attachments entries must be objects');
+    }
+    const rel = row.path || row.file || row.filename;
+    const absolutePath = resolveRelativeAttachmentPath(caseDir, rel);
+    return attachmentFromFile(absolutePath, row);
+  });
+}
+
+function listOpenapiJsonFiles(absoluteDir, allowList) {
+  if (!fs.existsSync(absoluteDir)) {
+    throw new Error(`Role assistant openapiDir not found: ${absoluteDir}`);
+  }
+  const names = fs
+    .readdirSync(absoluteDir)
+    .filter((entry) => /\.json$/i.test(entry))
+    .sort();
+  if (Array.isArray(allowList) && allowList.length > 0) {
+    const wanted = new Set(allowList.map((row) => String(row).trim()).filter(Boolean));
+    return names.filter((name) => wanted.has(name));
+  }
+  return names;
+}
+
+function collectOpenapiDirAttachments(caseDir, input) {
+  if (typeof input.openapiDir !== 'string' || !input.openapiDir.trim()) {
+    return [];
+  }
+  const absoluteDir = path.resolve(caseDir, input.openapiDir.trim());
+  const files = listOpenapiJsonFiles(absoluteDir, input.openapiFiles);
+  if (files.length === 0) {
+    throw new Error(`Role assistant openapiDir has no matching *.json files: ${absoluteDir}`);
+  }
+  return files.map((name) => attachmentFromFile(path.join(absoluteDir, name), { role: 'openapi' }));
+}
+
+/**
+ * Build ATT-shaped attachments for work.start from case input.
+ * @param {Object} testCase - Normalized case (may include sourceFile)
+ * @returns {Object[]|undefined}
+ */
+function buildStartAttachments(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input && !Array.isArray(testCase.input)
+      ? testCase.input
+      : {};
+  const caseDir = resolveCaseDirectory(testCase);
+  const fromExplicit = collectExplicitAttachments(caseDir, input.attachments);
+  const fromDir = collectOpenapiDirAttachments(caseDir, input);
+  const merged = [...fromExplicit, ...fromDir];
+  if (merged.length === 0) {
+    return undefined;
+  }
+  return merged;
+}
+
+module.exports = {
+  buildStartAttachments,
+  resolveCaseDirectory,
+  attachmentFromFile
+};

package/lib/role-assistant/test-runner-bid-apply.js

@@ -1,7 +1,10 @@
 /**
  * Soft-loop BID apply after workspace.createsystem (suite 002 / plan 512.4).
- * @fileoverview Apply input.bidPath into builder-api workspace when Runtime COM
- * cannot yet invoke template.applyintegrationdefinition (RA facade not refreshed).
+ * @fileoverview LAB-ONLY debt helper: POST Builder-api HTTP apply when the RA
+ * soft loop needs a package materialize. Product path is Decision Engine →
+ * capability.execute(template.applyintegrationdefinition) → COM/CIP.
+ * Do not treat this module as the product apply path once Runtime COM invoke
+ * works for the suite (plan 517.5). Non-product — lab helper only.
  */
 
 'use strict';
@@ -12,6 +15,7 @@ const {
   loadCaseBidDocument,
   resolveTargetSystemKey
 } = require('./test-runner-bid-document');
+const { buildStartAttachments } = require('./test-runner-attachments');
 
 /**
  * @returns {string}
@@ -59,6 +63,7 @@ function extractBearer(authConfig) {
 }
 
 /**
+ * True when wait is for template.applyintegrationdefinition and a case BID exists.
  * @param {Object} testCase
  * @param {Object} wait
  * @returns {boolean}
@@ -71,10 +76,95 @@ function shouldApplyBidAfterWait(testCase, wait) {
   const capability = String(
     wait.questionKey || wait.objectRef?.capabilityKey || wait.prompt || ''
   ).toLowerCase();
-  return (
-    capability.includes('createsystem') ||
-    capability.includes('applyintegrationdefinition')
-  );
+  // Product path: DE → capability.execute(template.applyintegrationdefinition).
+  return capability.includes('applyintegrationdefinition');
+}
+
+/**
+ * Lab-only soft HTTP BID apply. Hard cases (expected.soft !== true) must rely on
+ * Runtime COM/CIP apply after respond+continue — not Builder-api HTTP (517.5 / 517.4.7).
+ * @param {Object} testCase
+ * @param {Object} wait
+ * @returns {boolean}
+ */
+function shouldSoftHttpBidApply(testCase, wait) {
+  if (!shouldApplyBidAfterWait(testCase, wait)) {
+    return false;
+  }
+  return testCase?.expected?.soft === true;
+}
+
+/**
+ * @param {Object} testCase
+ * @returns {Object[]|null}
+ */
+function collectOpenApiPersistDocuments(testCase) {
+  let attachments = [];
+  try {
+    attachments = buildStartAttachments(testCase) || [];
+  } catch (_err) {
+    return null;
+  }
+  const documents = attachments
+    .filter((row) => row && (row.role === 'openapi' || !row.role) && row.body)
+    .map((row) => ({
+      filename: row.filename || row.name,
+      body: row.body
+    }))
+    .filter((row) => row.filename);
+  return documents.length > 0 ? documents : null;
+}
+
+/**
+ * @param {Response} res
+ * @param {string} label
+ * @returns {Promise<Object|null>}
+ */
+async function readBuilderApiJsonOrThrow(res, label) {
+  const text = await res.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch (_err) {
+    body = { raw: text };
+  }
+  if (!res.ok) {
+    const err = new Error(
+      `${label} HTTP ${res.status}: ${typeof body === 'object' ? JSON.stringify(body).slice(0, 300) : text}`
+    );
+    err.status = res.status;
+    throw err;
+  }
+  return body && body.data ? body.data : body;
+}
+
+/**
+ * Lab debt: stage suite OpenAPI into workspace via 517.2 persist API before apply.
+ * Product path is DE → capability.execute(persistsuppliedopenapi).
+ * @param {Object} authConfig
+ * @param {Object} testCase
+ * @param {string} systemKey
+ * @returns {Promise<Object|null>}
+ */
+async function persistCaseOpenApiViaBuilderApi(authConfig, testCase, systemKey) {
+  const token = extractBearer(authConfig);
+  if (!token || !systemKey) {
+    return null;
+  }
+  const documents = collectOpenApiPersistDocuments(testCase);
+  if (!documents) {
+    return null;
+  }
+  const url = `${resolveBuilderApiBaseUrl()}/api/v1/builder/systems/${encodeURIComponent(systemKey)}/openapi/persist-supplied`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ documents })
+  });
+  return readBuilderApiJsonOrThrow(res, 'OpenAPI persist failed');
 }
 
 /**
@@ -89,6 +179,7 @@ async function applyCaseBidViaBuilderApi(authConfig, testCase) {
   if (!bid || !systemKey || !token) {
     return null;
   }
+  await persistCaseOpenApiViaBuilderApi(authConfig, testCase, systemKey);
   const url = `${resolveBuilderApiBaseUrl()}/api/v1/builder/systems/${encodeURIComponent(systemKey)}/integration-definition/apply`;
   const res = await fetch(url, {
     method: 'POST',
@@ -98,25 +189,13 @@ async function applyCaseBidViaBuilderApi(authConfig, testCase) {
     },
     body: JSON.stringify({ integrationDefinition: bid, force: true })
   });
-  const text = await res.text();
-  let body = null;
-  try {
-    body = text ? JSON.parse(text) : null;
-  } catch (_err) {
-    body = { raw: text };
-  }
-  if (!res.ok) {
-    const err = new Error(
-      `BID apply failed HTTP ${res.status}: ${typeof body === 'object' ? JSON.stringify(body).slice(0, 300) : text}`
-    );
-    err.status = res.status;
-    throw err;
-  }
-  return body && body.data ? body.data : body;
+  return readBuilderApiJsonOrThrow(res, 'BID apply failed');
 }
 
 module.exports = {
   resolveBuilderApiBaseUrl,
   shouldApplyBidAfterWait,
+  shouldSoftHttpBidApply,
+  persistCaseOpenApiViaBuilderApi,
   applyCaseBidViaBuilderApi
 };

package/lib/role-assistant/test-runner-bid-document.js

@@ -5,8 +5,8 @@
 
 'use strict';
 
-const fs = require('../internal/fs-real-sync');
 const path = require('path');
+const fs = require('../internal/fs-real-sync');
 
 /**
  * @param {Object} testCase