scene-capability-engine 3.6.65 → 3.6.67

package/lib/semantic/shared-publication.js

@@ -0,0 +1,592 @@
+const path = require('path');
+const crypto = require('crypto');
+const fs = require('fs-extra');
+const { getSceStateStore } = require('../state/sce-state-store');
+const { exportSemanticLibraryDelta } = require('./delta-export');
+
+const SHARED_LIBRARY_ROOT = '.sce/knowledge/semantic-shared';
+const SHARED_LIBRARY_INDEX_API_VERSION = 'sce.semantic.shared-library.index/v0.1';
+const SHARED_LIBRARY_ENTRY_API_VERSION = 'sce.semantic.shared-library.entry/v0.1';
+const SHARED_LIBRARY_ROOT_INDEX_API_VERSION = 'sce.semantic.shared-library.root-index/v0.1';
+const SEMANTIC_PUBLICATION_REPORT_API_VERSION = 'sce.semantic.publication-report/v0.1';
+const GOVERNED_PUBLICATION_MAX_PENALTY_SCORE = 20;
+const SUPPORTED_TARGET_LIBRARIES = new Set([
+  'experience-library',
+  'ontology-capability-library',
+  'application-library'
+]);
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizeInteger(value, fallback = 0) {
+  const parsed = Number.parseInt(`${value}`, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+}
+
+function isObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function summarizeArchiveMetrics(archive = {}) {
+  if (!isObject(archive)) {
+    return {};
+  }
+  return {
+    archive_class: normalizeString(archive.archive_class) || null,
+    archive_reuse_scope: normalizeString(archive.reuse_scope) || null,
+    archive_reason_code: normalizeString(archive.reason_code) || null
+  };
+}
+
+async function readJsonIfExists(fileSystem, absolutePath, fallback) {
+  if (!await fileSystem.pathExists(absolutePath)) {
+    return fallback;
+  }
+  try {
+    return await fileSystem.readJson(absolutePath);
+  } catch (_error) {
+    return fallback;
+  }
+}
+
+function toProjectRelative(projectPath, targetPath) {
+  return path.relative(projectPath, targetPath).replace(/\\/g, '/');
+}
+
+function resolveDefaultSemanticPublicationReportOutFile(specId = '') {
+  const normalizedSpecId = normalizeString(specId);
+  if (!normalizedSpecId) {
+    return '';
+  }
+  return `.sce/specs/${normalizedSpecId}/publications/semantic/latest.json`;
+}
+
+function resolveSharedLibraryEntryRelativePath(targetLibrary = '', capabilityId = '') {
+  const normalizedLibrary = normalizeString(targetLibrary);
+  const normalizedCapabilityId = normalizeString(capabilityId);
+  if (!normalizedLibrary || !normalizedCapabilityId) {
+    return '';
+  }
+  return `${SHARED_LIBRARY_ROOT}/${normalizedLibrary}/entries/${normalizedCapabilityId}.json`;
+}
+
+function resolveSharedLibraryIndexRelativePath(targetLibrary = '') {
+  const normalizedLibrary = normalizeString(targetLibrary);
+  if (!normalizedLibrary) {
+    return '';
+  }
+  return `${SHARED_LIBRARY_ROOT}/${normalizedLibrary}/index.json`;
+}
+
+function buildPublicationReceiptId() {
+  return `sem-pub-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
+}
+
+function assessGovernedPublicationGate(ledger = {}) {
+  const metrics = isObject(ledger.metrics) ? ledger.metrics : {};
+  const penaltyScore = Number(metrics.governance_penalty_score);
+  const refuseCount = Number.parseInt(`${metrics.governance_refuse_count || 0}`, 10) || 0;
+  const executionBlockedCount = Number.parseInt(`${metrics.governance_execution_blocked_count || 0}`, 10) || 0;
+  const governedCount = Number.parseInt(`${metrics.governance_governed_count || 0}`, 10) || 0;
+  const reasons = [];
+
+  if (refuseCount > 0) {
+    reasons.push({
+      reason: 'governance-refuse-history',
+      refuse_count: refuseCount
+    });
+  }
+  if (executionBlockedCount > 0) {
+    reasons.push({
+      reason: 'governance-execution-blocked-history',
+      execution_blocked_count: executionBlockedCount
+    });
+  }
+  if (Number.isFinite(penaltyScore) && penaltyScore >= GOVERNED_PUBLICATION_MAX_PENALTY_SCORE) {
+    reasons.push({
+      reason: 'governance-penalty-too-high',
+      governance_penalty_score: Number(penaltyScore.toFixed(2)),
+      max_allowed_penalty_score: GOVERNED_PUBLICATION_MAX_PENALTY_SCORE
+    });
+  }
+
+  return {
+    allowed: reasons.length === 0,
+    reasons,
+    metrics: {
+      governance_penalty_score: Number.isFinite(penaltyScore) ? Number(penaltyScore.toFixed(2)) : 0,
+      governance_governed_count: governedCount,
+      governance_refuse_count: refuseCount,
+      governance_execution_blocked_count: executionBlockedCount
+    }
+  };
+}
+
+async function applyGovernedPublicationBlockedState(lesson = {}, ledger = {}, context = {}, dependencies = {}) {
+  const store = dependencies.stateStore;
+  if (!store || !lesson || !lesson.lesson_id) {
+    return { lesson, ledger };
+  }
+
+  const generatedAt = normalizeString(context.generated_at) || new Date().toISOString();
+  const gate = isObject(context.governed_gate) ? context.governed_gate : {};
+  const blockedReason = gate.reasons && gate.reasons.length > 0
+    ? gate.reasons.map((item) => item.reason).join(',')
+    : 'governed-publication-gate';
+  const lessonMetadata = isObject(lesson.metadata) ? lesson.metadata : {};
+  const lessonPublish = isObject(lessonMetadata.publish) ? lessonMetadata.publish : {};
+  const blockedMetadata = {
+    ...lessonPublish,
+    consent_model: normalizeString(lessonPublish.consent_model) || 'adopt-implied',
+    publish_required: lessonPublish.publish_required === true,
+    publish_state: 'blocked',
+    blocked_at: generatedAt,
+    blocked_reason: blockedReason,
+    blocked_gate: gate
+  };
+
+  const blockedLesson = await store.upsertSemanticLessonCandidate({
+    ...lesson,
+    status: 'publish_blocked',
+    metadata: {
+      ...lessonMetadata,
+      publish: blockedMetadata
+    },
+    updated_at: generatedAt
+  });
+
+  const nextLedger = await store.upsertSemanticCapabilityLedger({
+    ...(ledger || {}),
+    capability_id: normalizeString(ledger && ledger.capability_id) || null,
+    lesson_id: normalizeString(lesson.lesson_id),
+    evaluation_run_id: normalizeString(ledger && ledger.evaluation_run_id) || null,
+    project_id: normalizeString(blockedLesson.project_id) || normalizeString(ledger && ledger.project_id) || null,
+    channel_id: normalizeString(ledger && ledger.channel_id) || normalizeString(lessonMetadata.channel_id) || null,
+    session_id: normalizeString(ledger && ledger.session_id) || normalizeString(lessonMetadata.session_id) || null,
+    scene_id: normalizeString(blockedLesson.scene_id) || normalizeString(ledger && ledger.scene_id) || null,
+    spec_id: normalizeString(blockedLesson.spec_id) || normalizeString(ledger && ledger.spec_id) || null,
+    target_library: normalizeString(ledger && ledger.target_library) || null,
+    capability_status: normalizeString(ledger && ledger.capability_status) || 'active',
+    publish_state: 'blocked',
+    publication: {
+      ...(isObject(ledger && ledger.publication) ? ledger.publication : {}),
+      ...blockedMetadata
+    },
+    lineage: isObject(ledger && ledger.lineage) ? ledger.lineage : {},
+    metrics: {
+      ...(isObject(ledger && ledger.metrics) ? ledger.metrics : {}),
+      governed_publication_gate_blocked: true
+    },
+    activation_count: ledger && ledger.activation_count,
+    activation_success_count: ledger && ledger.activation_success_count,
+    activation_mixed_count: ledger && ledger.activation_mixed_count,
+    activation_negative_count: ledger && ledger.activation_negative_count,
+    quarantine_count: ledger && ledger.quarantine_count,
+    last_activated_at: ledger && ledger.last_activated_at,
+    last_quality_signal: ledger && ledger.last_quality_signal,
+    last_runtime: ledger && ledger.last_runtime,
+    rank_score: ledger && ledger.rank_score,
+    created_at: normalizeString(ledger && ledger.created_at) || generatedAt,
+    updated_at: generatedAt
+  });
+
+  return {
+    lesson: blockedLesson,
+    ledger: nextLedger
+  };
+}
+
+async function upsertSharedLibraryIndex(targetLibrary, receipt = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const libraryIndexRelativePath = resolveSharedLibraryIndexRelativePath(targetLibrary);
+  const libraryIndexAbsolutePath = path.join(projectPath, libraryIndexRelativePath);
+  const existingIndex = await readJsonIfExists(fileSystem, libraryIndexAbsolutePath, {
+    api_version: SHARED_LIBRARY_INDEX_API_VERSION,
+    target_library: targetLibrary,
+    updated_at: null,
+    entries: []
+  });
+  const existingEntries = Array.isArray(existingIndex.entries) ? existingIndex.entries : [];
+  const nextEntries = existingEntries
+    .filter((item) => normalizeString(item.capability_id) !== normalizeString(receipt.capability_id));
+  nextEntries.push({
+    capability_id: normalizeString(receipt.capability_id) || null,
+    lesson_id: normalizeString(receipt.lesson_id) || null,
+    project_id: normalizeString(receipt.project_id) || null,
+    channel_id: normalizeString(receipt.channel_id) || null,
+    session_id: normalizeString(receipt.session_id) || null,
+    scene_id: normalizeString(receipt.scene_id) || null,
+    spec_id: normalizeString(receipt.spec_id) || null,
+    published_at: normalizeString(receipt.published_at) || null,
+    entry_file: normalizeString(receipt.entry_file) || null,
+    source_manifest: normalizeString(receipt.source_manifest) || null,
+    receipt_id: normalizeString(receipt.receipt_id) || null
+  });
+  nextEntries.sort((left, right) => {
+    const leftTime = Date.parse(left.published_at || '') || 0;
+    const rightTime = Date.parse(right.published_at || '') || 0;
+    return rightTime - leftTime;
+  });
+  const nextIndex = {
+    api_version: SHARED_LIBRARY_INDEX_API_VERSION,
+    target_library: targetLibrary,
+    updated_at: normalizeString(receipt.published_at) || new Date().toISOString(),
+    entries: nextEntries
+  };
+  await fileSystem.ensureDir(path.dirname(libraryIndexAbsolutePath));
+  await fileSystem.writeJson(libraryIndexAbsolutePath, nextIndex, { spaces: 2 });
+
+  const rootIndexAbsolutePath = path.join(projectPath, SHARED_LIBRARY_ROOT, 'index.json');
+  const existingRootIndex = await readJsonIfExists(fileSystem, rootIndexAbsolutePath, {
+    api_version: SHARED_LIBRARY_ROOT_INDEX_API_VERSION,
+    updated_at: null,
+    libraries: []
+  });
+  const existingLibraries = Array.isArray(existingRootIndex.libraries) ? existingRootIndex.libraries : [];
+  const nextLibraries = existingLibraries
+    .filter((item) => normalizeString(item.target_library) !== targetLibrary);
+  nextLibraries.push({
+    target_library: targetLibrary,
+    entry_count: nextEntries.length,
+    index_file: libraryIndexRelativePath,
+    updated_at: nextIndex.updated_at
+  });
+  nextLibraries.sort((left, right) => `${left.target_library}`.localeCompare(`${right.target_library}`));
+  await fileSystem.ensureDir(path.dirname(rootIndexAbsolutePath));
+  await fileSystem.writeJson(rootIndexAbsolutePath, {
+    api_version: SHARED_LIBRARY_ROOT_INDEX_API_VERSION,
+    updated_at: nextIndex.updated_at,
+    libraries: nextLibraries
+  }, { spaces: 2 });
+
+  return {
+    library_index_file: libraryIndexRelativePath,
+    root_index_file: `${SHARED_LIBRARY_ROOT}/index.json`
+  };
+}
+
+async function publishSemanticLibraryDelta(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const store = dependencies.stateStore || getSceStateStore(projectPath, {
+    fileSystem,
+    env: dependencies.env,
+    sqliteModule: dependencies.sqliteModule,
+    noCache: dependencies.noCache === true
+  });
+
+  const requestedProjectId = normalizeString(options.project_id || options.projectId);
+  const requestedSpecId = normalizeString(options.spec_id || options.specId);
+  const requestedLessonId = normalizeString(options.lesson_id || options.lessonId);
+  const requestedCapabilityId = normalizeString(options.capability_id || options.capabilityId);
+  const inputFile = normalizeString(options.input_file || options.inputFile);
+  const limit = normalizeInteger(options.limit, 100);
+  const syncLedger = typeof dependencies.syncSemanticCapabilityLedger === 'function'
+    ? dependencies.syncSemanticCapabilityLedger
+    : null;
+
+  let deltaPayload;
+  let sourceManifest = '';
+  if (inputFile) {
+    const absoluteInputPath = path.isAbsolute(inputFile)
+      ? inputFile
+      : path.join(projectPath, inputFile);
+    deltaPayload = await fileSystem.readJson(absoluteInputPath);
+    sourceManifest = toProjectRelative(projectPath, absoluteInputPath);
+  } else {
+    deltaPayload = await exportSemanticLibraryDelta({
+      project_id: requestedProjectId,
+      spec_id: requestedSpecId,
+      lesson_id: requestedLessonId,
+      capability_id: requestedCapabilityId,
+      limit
+    }, {
+      ...dependencies,
+      projectPath,
+      fileSystem,
+      stateStore: store
+    });
+    sourceManifest = normalizeString(deltaPayload && deltaPayload.out_file);
+  }
+
+  const entries = Array.isArray(deltaPayload && deltaPayload.entries) ? deltaPayload.entries : [];
+  const filteredEntries = entries.filter((entry) => {
+    if (requestedLessonId && normalizeString(entry && entry.lesson_id) !== requestedLessonId) {
+      return false;
+    }
+    if (requestedCapabilityId && normalizeString(entry && entry.capability_id) !== requestedCapabilityId) {
+      return false;
+    }
+    return true;
+  });
+  const projectId = requestedProjectId || normalizeString(deltaPayload && deltaPayload.project_id) || null;
+  const specId = requestedSpecId || normalizeString(deltaPayload && deltaPayload.spec_id) || null;
+  const generatedAt = new Date().toISOString();
+  const published = [];
+  const blocked = [];
+
+  for (const entry of filteredEntries) {
+    const capabilityId = normalizeString(entry && entry.capability_id);
+    const lessonId = normalizeString(entry && entry.lesson_id);
+    const targetLibrary = normalizeString(entry && entry.target_library);
+    const sanitized = Boolean(entry && entry.sanitized === true);
+
+    if (!capabilityId || !lessonId) {
+      blocked.push({
+        capability_id: capabilityId || null,
+        lesson_id: lessonId || null,
+        target_library: targetLibrary || null,
+        reason: 'missing-capability-or-lesson-id'
+      });
+      continue;
+    }
+    if (!SUPPORTED_TARGET_LIBRARIES.has(targetLibrary)) {
+      blocked.push({
+        capability_id: capabilityId,
+        lesson_id: lessonId,
+        target_library: targetLibrary || null,
+        reason: 'unsupported-target-library'
+      });
+      continue;
+    }
+    if (!sanitized) {
+      blocked.push({
+        capability_id: capabilityId,
+        lesson_id: lessonId,
+        target_library: targetLibrary,
+        reason: 'unsanitized-delta'
+      });
+      continue;
+    }
+
+    const lesson = await store.getSemanticLessonCandidate(lessonId);
+    if (!lesson) {
+      blocked.push({
+        capability_id: capabilityId,
+        lesson_id: lessonId,
+        target_library: targetLibrary,
+        reason: 'lesson-not-found'
+      });
+      continue;
+    }
+    const existingLedger = await store.getSemanticCapabilityLedger(capabilityId);
+    const governedGate = assessGovernedPublicationGate(existingLedger || {});
+    if (!governedGate.allowed) {
+      await applyGovernedPublicationBlockedState(lesson, existingLedger || {}, {
+        generated_at: generatedAt,
+        governed_gate: governedGate
+      }, {
+        stateStore: store
+      });
+      blocked.push({
+        capability_id: capabilityId,
+        lesson_id: lessonId,
+        target_library: targetLibrary,
+        reason: 'governed-publication-gate',
+        gate: governedGate
+      });
+      continue;
+    }
+
+    const entryRelativePath = resolveSharedLibraryEntryRelativePath(targetLibrary, capabilityId);
+    const entryAbsolutePath = path.join(projectPath, entryRelativePath);
+    const receiptId = buildPublicationReceiptId();
+    const lessonMetadata = isObject(lesson.metadata) ? lesson.metadata : {};
+    const archive = isObject(entry.archive)
+      ? entry.archive
+      : (isObject(lessonMetadata.archive) ? lessonMetadata.archive : null);
+    const libraryEntry = {
+      api_version: SHARED_LIBRARY_ENTRY_API_VERSION,
+      receipt_id: receiptId,
+      published_at: generatedAt,
+      project_id: normalizeString(lesson.project_id) || projectId,
+      channel_id: normalizeString(lessonMetadata.channel_id) || null,
+      session_id: normalizeString(lessonMetadata.session_id) || null,
+      scene_id: normalizeString(lesson.scene_id) || normalizeString(entry.scene_id) || null,
+      spec_id: normalizeString(lesson.spec_id) || specId,
+      capability_id: capabilityId,
+      lesson_id: lessonId,
+      target_library: targetLibrary,
+      title: normalizeString(entry.title) || normalizeString(lesson.title) || null,
+      summary: normalizeString(entry.summary) || normalizeString(lesson.summary) || null,
+      heuristic: normalizeString(entry.heuristic) || normalizeString(lesson.heuristic) || null,
+      lesson_type: normalizeString(entry.lesson_type) || normalizeString(lesson.lesson_type) || null,
+      confidence: Number.isFinite(Number(entry.confidence)) ? Number(entry.confidence) : Number(lesson.confidence),
+      lineage: isObject(entry.lineage) ? entry.lineage : {},
+      archive,
+      publication: {
+        ...(isObject(entry.publication) ? entry.publication : {}),
+        publish_state: 'published-shared',
+        source_manifest: sourceManifest || null,
+        entry_file: entryRelativePath
+      },
+      sanitized: true
+    };
+
+    await fileSystem.ensureDir(path.dirname(entryAbsolutePath));
+    await fileSystem.writeJson(entryAbsolutePath, libraryEntry, { spaces: 2 });
+
+    const indexPointers = await upsertSharedLibraryIndex(targetLibrary, {
+      capability_id: capabilityId,
+      lesson_id: lessonId,
+      project_id: libraryEntry.project_id,
+      channel_id: libraryEntry.channel_id,
+      session_id: libraryEntry.session_id,
+      scene_id: libraryEntry.scene_id,
+      spec_id: libraryEntry.spec_id,
+      published_at: generatedAt,
+      entry_file: entryRelativePath,
+      source_manifest: sourceManifest,
+      receipt_id: receiptId
+    }, {
+      projectPath,
+      fileSystem
+    });
+
+    const lessonPublish = isObject(lesson.metadata) && isObject(lesson.metadata.publish)
+      ? lesson.metadata.publish
+      : {};
+    const publishedMetadata = {
+      ...lessonPublish,
+      consent_model: normalizeString(lessonPublish.consent_model) || 'adopt-implied',
+      publish_required: lessonPublish.publish_required === true,
+      publish_state: 'published-shared',
+      published_at: generatedAt,
+      published_library: targetLibrary,
+      published_receipt_id: receiptId,
+      published_entry_file: entryRelativePath,
+      published_index_file: indexPointers.library_index_file,
+      source_manifest: sourceManifest || null
+    };
+    const publishedLesson = await store.upsertSemanticLessonCandidate({
+      ...lesson,
+      status: 'published-shared',
+      metadata: {
+        ...(isObject(lesson.metadata) ? lesson.metadata : {}),
+        ...(archive ? { archive } : {}),
+        publish: publishedMetadata
+      },
+      updated_at: generatedAt
+    });
+
+    await store.upsertSemanticCapabilityLedger({
+      ...(existingLedger || {}),
+      capability_id: capabilityId,
+      lesson_id: lessonId,
+      evaluation_run_id: normalizeString(entry.lineage && entry.lineage.evaluation_run_id)
+        || normalizeString(existingLedger && existingLedger.evaluation_run_id)
+        || null,
+      project_id: normalizeString(publishedLesson.project_id) || normalizeString(existingLedger && existingLedger.project_id) || projectId,
+      channel_id: normalizeString(existingLedger && existingLedger.channel_id) || null,
+      session_id: normalizeString(existingLedger && existingLedger.session_id) || null,
+      scene_id: normalizeString(publishedLesson.scene_id) || normalizeString(existingLedger && existingLedger.scene_id) || null,
+      spec_id: normalizeString(publishedLesson.spec_id) || normalizeString(existingLedger && existingLedger.spec_id) || specId,
+      target_library: targetLibrary,
+      capability_status: normalizeString(existingLedger && existingLedger.capability_status) || 'active',
+      publish_state: 'published-shared',
+      publication: {
+        ...(isObject(existingLedger && existingLedger.publication) ? existingLedger.publication : {}),
+        ...publishedMetadata,
+        target_library: targetLibrary,
+        ...(archive ? { archive } : {})
+      },
+      lineage: {
+        ...(isObject(existingLedger && existingLedger.lineage) ? existingLedger.lineage : {}),
+        ...(archive ? { archive } : {})
+      },
+      metrics: {
+        ...(isObject(existingLedger && existingLedger.metrics) ? existingLedger.metrics : {}),
+        ...summarizeArchiveMetrics(archive)
+      },
+      activation_count: existingLedger && existingLedger.activation_count,
+      activation_success_count: existingLedger && existingLedger.activation_success_count,
+      activation_mixed_count: existingLedger && existingLedger.activation_mixed_count,
+      activation_negative_count: existingLedger && existingLedger.activation_negative_count,
+      quarantine_count: existingLedger && existingLedger.quarantine_count,
+      last_activated_at: existingLedger && existingLedger.last_activated_at,
+      last_quality_signal: existingLedger && existingLedger.last_quality_signal,
+      last_runtime: existingLedger && existingLedger.last_runtime,
+      rank_score: existingLedger && existingLedger.rank_score,
+      created_at: normalizeString(existingLedger && existingLedger.created_at) || generatedAt,
+      updated_at: generatedAt
+    });
+
+    if (syncLedger) {
+      await syncLedger(publishedLesson, {
+        capability_id: capabilityId,
+        evaluation_run_id: normalizeString(entry.lineage && entry.lineage.evaluation_run_id)
+          || normalizeString(existingLedger && existingLedger.evaluation_run_id)
+          || null,
+        target_library: targetLibrary,
+        capability_status: normalizeString(existingLedger && existingLedger.capability_status) || 'active',
+        publish_state: 'published-shared',
+        updated_at: generatedAt
+      }, {
+        ...dependencies,
+        projectPath,
+        fileSystem,
+        stateStore: store
+      });
+    }
+
+    published.push({
+      capability_id: capabilityId,
+      lesson_id: lessonId,
+      target_library: targetLibrary,
+      published_at: generatedAt,
+      receipt_id: receiptId,
+      entry_file: entryRelativePath,
+      index_file: indexPointers.library_index_file
+    });
+  }
+
+  const payload = {
+    api_version: SEMANTIC_PUBLICATION_REPORT_API_VERSION,
+    mode: 'semantic-publish-delta',
+    success: blocked.length === 0,
+    generated_at: generatedAt,
+    project_id: projectId,
+    spec_id: specId,
+    source_manifest: sourceManifest || null,
+    mirror_root: SHARED_LIBRARY_ROOT,
+    totals: {
+      entries: entries.length,
+      matched: filteredEntries.length,
+      published: published.length,
+      blocked: blocked.length
+    },
+    published,
+    blocked
+  };
+
+  const outFile = normalizeString(options.out_file || options.outFile)
+    || resolveDefaultSemanticPublicationReportOutFile(specId);
+  if (outFile) {
+    const absoluteOutPath = path.isAbsolute(outFile)
+      ? outFile
+      : path.join(projectPath, outFile);
+    await fileSystem.ensureDir(path.dirname(absoluteOutPath));
+    await fileSystem.writeJson(absoluteOutPath, payload, { spaces: 2 });
+    payload.out_file = toProjectRelative(projectPath, absoluteOutPath);
+  }
+
+  return payload;
+}
+
+module.exports = {
+  SHARED_LIBRARY_ROOT,
+  resolveDefaultSemanticPublicationReportOutFile,
+  resolveSharedLibraryEntryRelativePath,
+  resolveSharedLibraryIndexRelativePath,
+  upsertSharedLibraryIndex,
+  publishSemanticLibraryDelta
+};