@mindrian_os/install 1.13.0-beta.11

package/lib/import/router.test.cjs

@@ -0,0 +1,356 @@
+'use strict';
+
+/**
+ * Tests for lib/import/router.cjs -- Phase 80 Stage 03.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+
+const {
+  routeFiles,
+  pickSlug,
+  slugifyTitle,
+  resolveSectionSubpath,
+  nextNonCollidingFolder,
+  INBOX_SUGGESTED_THRESHOLD
+} = require('./router.cjs');
+
+function mkTmp(label) {
+  const dir = path.join(
+    os.tmpdir(),
+    'router-test-' + label + '-' + crypto.randomBytes(6).toString('hex')
+  );
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function makeRoom(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'STATE.md'), '# STATE\n');
+}
+
+function makeSourceFile(dir, name, content) {
+  const abs = path.join(dir, name);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content || '# ' + name + '\n');
+  return abs;
+}
+
+function baseManifest(roomDir, sourceVault) {
+  return {
+    schema_version: '1.0',
+    import_id: '2026-04-13-problem-solution',
+    created_at: new Date().toISOString(),
+    source_vault: sourceVault,
+    destination_room: roomDir,
+    mode: 'copy',
+    status: 'in_progress',
+    main_topic: null,
+    main_topic_source: null,
+    stage_states: {
+      ingest:   { status: 'complete', completed_at: null, files_scanned: 0 },
+      classify: { status: 'complete', completed_at: null, human_edited: false, edits_count: 0 },
+      route:    { status: 'pending', completed_at: null, files_moved: 0, collisions: 0 },
+      enrich:   { status: 'pending', completed_at: null, wikilinks_added: 0, rooms_md_created: 0, minto_stubs_created: 0 }
+    },
+    files: [],
+    people: [],
+    meetings: [],
+    collisions: [],
+    warnings: [],
+    undo: { is_undone: false, undone_at: null, undone_to_directory: null }
+  };
+}
+
+function makeFile(id, abs, section, confidence, extras) {
+  const f = {
+    id: id,
+    source_path: path.basename(abs),
+    source_abs_path: abs,
+    source_size: fs.statSync(abs).size,
+    source_mtime: new Date().toISOString(),
+    source_hash: 'hash-' + id,
+    source_frontmatter: (extras && extras.source_frontmatter) || {},
+    source_wikilinks: (extras && extras.source_wikilinks) || [],
+    parent_folder: null,
+    classification: {
+      section: section,
+      confidence: confidence,
+      evidence: 'test',
+      decision: 'AUTO',
+      stage: 'classify'
+    },
+    collision: false
+  };
+  return f;
+}
+
+// ---------- Test 1: slug rules ----------
+(function test_slug_rules() {
+  assert.equal(slugifyTitle('Onboarding pain'), 'onboarding-pain');
+  assert.equal(slugifyTitle('Hello, World!'), 'hello-world');
+  assert.equal(slugifyTitle('A'.repeat(200)).length, 60);
+  console.log('ok test_slug_rules');
+})();
+
+// ---------- Test 2: frontmatter title override ----------
+(function test_frontmatter_title_override() {
+  const f = {
+    source_path: 'p.md',
+    source_frontmatter: { title: 'Pricing model' }
+  };
+  assert.equal(pickSlug(f), 'pricing-model');
+})();
+console.log('ok test_frontmatter_title_override');
+
+// ---------- Test 3: nested layout + full routing happy path ----------
+(function test_nested_layout() {
+  const root = mkTmp('nested');
+  const room = path.join(root, 'room');
+  const src = path.join(root, 'vault');
+  makeRoom(room);
+  fs.mkdirSync(src, { recursive: true });
+  const a = makeSourceFile(src, 'onboarding-pain.md', '---\ntitle: Onboarding pain\n---\nbody\n');
+  const m = baseManifest(room, src);
+  m.files.push(makeFile('f1', a, 'problem-definition', 0.9));
+  routeFiles(m);
+  const expectedFolder = path.join('problem-definition', 'onboarding-pain');
+  const expectedPath = path.join(expectedFolder, 'onboarding-pain.md');
+  assert.equal(m.files[0].destination_folder, expectedFolder);
+  assert.equal(m.files[0].destination_path, expectedPath);
+  assert.equal(m.files[0].destination_section, 'problem-definition');
+  assert.ok(fs.existsSync(path.join(room, expectedPath)));
+  console.log('ok test_nested_layout');
+})();
+
+// ---------- Test 4 + 5 + 6: inbox branching ----------
+(function test_inbox_branching() {
+  const root = mkTmp('inbox');
+  const room = path.join(root, 'room');
+  const src = path.join(root, 'vault');
+  makeRoom(room);
+  const hi = makeSourceFile(src, 'high.md', '# high\n');
+  const lo = makeSourceFile(src, 'low.md', '# low\n');
+  const edgeHi = makeSourceFile(src, 'edge-hi.md', '# edge hi\n');
+  const edgeLo = makeSourceFile(src, 'edge-lo.md', '# edge lo\n');
+  const m = baseManifest(room, src);
+  m.files.push(makeFile('f-hi', hi, 'inbox', 0.6));
+  m.files.push(makeFile('f-lo', lo, 'inbox', 0.3));
+  m.files.push(makeFile('f-edge-hi', edgeHi, 'inbox', 0.45));
+  m.files.push(makeFile('f-edge-lo', edgeLo, 'inbox', 0.4499));
+  routeFiles(m);
+
+  const byId = {};
+  m.files.forEach(function (f) { byId[f.id] = f; });
+
+  assert.ok(byId['f-hi'].destination_folder.startsWith('inbox' + path.sep + 'suggested'));
+  assert.ok(byId['f-hi'].destination_path.endsWith('high.md'));
+  assert.ok(byId['f-lo'].destination_folder.startsWith('inbox' + path.sep + 'unclassified'));
+  assert.ok(byId['f-edge-hi'].destination_folder.startsWith('inbox' + path.sep + 'suggested'));
+  assert.ok(byId['f-edge-lo'].destination_folder.startsWith('inbox' + path.sep + 'unclassified'));
+
+  // destination_section top-level should be "inbox"
+  assert.equal(byId['f-hi'].destination_section, 'inbox');
+  assert.equal(byId['f-lo'].destination_section, 'inbox');
+  console.log('ok test_inbox_branching');
+
+  // resolveSectionSubpath direct check
+  assert.equal(
+    resolveSectionSubpath({ section: 'inbox', confidence: 0.45 }, 'x'),
+    path.join('inbox', 'suggested', 'x')
+  );
+  assert.equal(
+    resolveSectionSubpath({ section: 'inbox', confidence: 0.44 }, 'x'),
+    path.join('inbox', 'unclassified', 'x')
+  );
+  assert.equal(INBOX_SUGGESTED_THRESHOLD, 0.45);
+})();
+
+// ---------- Test 7 + 8: collision handling ----------
+(function test_collision() {
+  const root = mkTmp('collision');
+  const room = path.join(root, 'room');
+  const src = path.join(root, 'vault');
+  makeRoom(room);
+  // Pre-existing room section with the same slug.
+  fs.mkdirSync(path.join(room, 'problem-definition', 'onboarding'), { recursive: true });
+  fs.writeFileSync(path.join(room, 'problem-definition', 'onboarding', 'onboarding.md'), '# old\n');
+
+  const a = makeSourceFile(src, 'onboarding.md', '# new\n');
+  const m = baseManifest(room, src);
+  m.files.push(makeFile('f1', a, 'problem-definition', 0.9));
+  routeFiles(m);
+
+  const dateSlug = m.import_id.slice(0, 10);
+  const expected = path.join('problem-definition', 'onboarding-imported-' + dateSlug);
+  assert.equal(m.files[0].destination_folder, expected);
+  assert.equal(m.collisions.length, 1);
+  assert.equal(m.collisions[0].reason, 'destination_folder_exists');
+  assert.equal(m.files[0].collision, true);
+
+  // Test 8: N+1 collision
+  const b = makeSourceFile(src, 'onboarding-2.md', '---\ntitle: onboarding\n---\n# newer\n');
+  const m2 = baseManifest(room, src);
+  m2.files.push(makeFile('f2', b, 'problem-definition', 0.9, { source_frontmatter: { title: 'onboarding' } }));
+  routeFiles(m2);
+  // Base exists AND -imported-{date} exists, so should be -imported-{date}-2
+  assert.ok(m2.files[0].destination_folder.endsWith('-imported-' + dateSlug + '-2'));
+  console.log('ok test_collision');
+})();
+
+// ---------- Test 9: refuse no STATE.md ----------
+(function test_refuse_no_state() {
+  const root = mkTmp('nostate');
+  const room = path.join(root, 'room');
+  fs.mkdirSync(room, { recursive: true });
+  // No STATE.md written.
+  const src = path.join(root, 'vault');
+  const a = makeSourceFile(src, 'a.md', '# a\n');
+  const m = baseManifest(room, src);
+  m.files.push(makeFile('f1', a, 'problem-definition', 0.9));
+  assert.throws(function () { routeFiles(m); }, /STATE.md/);
+  // Nothing should have been written.
+  assert.equal(fs.existsSync(path.join(room, 'problem-definition')), false);
+  console.log('ok test_refuse_no_state');
+})();
+
+// ---------- Test 10: provenance frontmatter ----------
+(function test_provenance() {
+  const root = mkTmp('prov');
+  const room = path.join(root, 'room');
+  const src = path.join(root, 'vault');
+  makeRoom(room);
+  const a = makeSourceFile(src, 'a.md', '# a\n');
+  const m = baseManifest(room, src);
+  m.files.push(makeFile('f1', a, 'problem-definition', 0.9));
+  routeFiles(m);
+  const written = fs.readFileSync(m.files[0].destination_abs_path, 'utf8');
+  assert.match(written, /_imported_from:/);
+  assert.match(written, /source_vault:/);
+  console.log('ok test_provenance');
+})();
+
+// ---------- Test 11: copy mode leaves source ----------
+(function test_copy_mode() {
+  const root = mkTmp('copy');
+  const room = path.join(root, 'room');
+  const src = path.join(root, 'vault');
+  makeRoom(room);
+  const a = makeSourceFile(src, 'a.md', '# a\n');
+  const m = baseManifest(room, src);
+  m.files.push(makeFile('f1', a, 'problem-definition', 0.9));
+  routeFiles(m);
+  assert.ok(fs.existsSync(a), 'source file must still exist in copy mode');
+  console.log('ok test_copy_mode');
+})();
+
+// ---------- Test 12: move mode unlinks source ----------
+(function test_move_mode() {
+  const root = mkTmp('move');
+  const room = path.join(root, 'room');
+  const src = path.join(root, 'vault');
+  makeRoom(room);
+  const a = makeSourceFile(src, 'a.md', '# a\n');
+  const m = baseManifest(room, src);
+  m.mode = 'move';
+  m.files.push(makeFile('f1', a, 'problem-definition', 0.9));
+  routeFiles(m);
+  assert.equal(fs.existsSync(a), false, 'source file must be unlinked in move mode');
+  console.log('ok test_move_mode');
+})();
+
+// ---------- Test 13: meetings detour ----------
+(function test_meetings_detour() {
+  const root = mkTmp('meet');
+  const room = path.join(root, 'room');
+  const src = path.join(root, 'vault');
+  makeRoom(room);
+  const a = makeSourceFile(src, '2026-01-15-team-sync.md', '# sync\n');
+  const m = baseManifest(room, src);
+  m.files.push(makeFile('f1', a, 'meetings', 0.9));
+  m.meetings.push({ source_file_id: 'f1' });
+  routeFiles(m);
+  assert.equal(m.files[0].destination_section, 'meetings-pending');
+  assert.ok(m.files[0].destination_folder.includes('meetings-pending'));
+  assert.ok(m.files[0].destination_path.includes('imports' + path.sep));
+  assert.ok(fs.existsSync(m.files[0].destination_abs_path));
+  console.log('ok test_meetings_detour');
+})();
+
+// ---------- Test 14: manifest update ----------
+(function test_manifest_update() {
+  const root = mkTmp('mu');
+  const room = path.join(root, 'room');
+  const src = path.join(root, 'vault');
+  makeRoom(room);
+  const a = makeSourceFile(src, 'a.md', '# a\n');
+  const b = makeSourceFile(src, 'b.md', '# b\n');
+  const m = baseManifest(room, src);
+  m.files.push(makeFile('f1', a, 'problem-definition', 0.9));
+  m.files.push(makeFile('f2', b, 'business-model', 0.9));
+  routeFiles(m);
+  assert.equal(m.stage_states.route.status, 'complete');
+  assert.equal(m.stage_states.route.files_moved, 2);
+  assert.equal(m.stage_states.route.collisions, 0);
+  assert.ok(m.stage_states.route.completed_at);
+  console.log('ok test_manifest_update');
+})();
+
+// ---------- nextNonCollidingFolder direct ----------
+(function test_next_non_colliding_direct() {
+  const root = mkTmp('nncf');
+  const room = path.join(root, 'room');
+  makeRoom(room);
+  // Fresh folder -- no collision.
+  const r = nextNonCollidingFolder(room, path.join('section', 'x'), '2026-04-13');
+  assert.equal(r.collided, false);
+  assert.equal(r.folder, path.join('section', 'x'));
+  console.log('ok test_next_non_colliding_direct');
+})();
+
+// ---------- create-speaker-profile --layout=import smoke test ----------
+(function test_create_speaker_profile_layout_import() {
+  const root = mkTmp('csp');
+  // Script requires room_dir to exist.
+  makeRoom(path.join(root, 'room'));
+  const scriptPath = path.resolve(__dirname, '..', '..', 'scripts', 'create-speaker-profile');
+  const res = spawnSync('bash', [
+    scriptPath,
+    path.join(root, 'room'),
+    '--layout=import',
+    '--role-bucket=core-team',
+    'jane-doe',
+    'Jane Doe'
+  ], { encoding: 'utf8' });
+  if (res.status !== 0) {
+    console.error('stdout:', res.stdout);
+    console.error('stderr:', res.stderr);
+  }
+  assert.equal(res.status, 0, 'create-speaker-profile --layout=import must exit 0');
+  const personDir = path.join(root, 'room', 'team', 'core-team', 'jane-doe');
+  assert.ok(fs.existsSync(path.join(personDir, 'jane-doe.md')), 'jane-doe.md missing');
+  assert.ok(fs.existsSync(path.join(personDir, 'ROOM.md')), 'ROOM.md missing');
+  assert.ok(fs.existsSync(path.join(personDir, 'mentions.md')), 'mentions.md missing');
+  assert.ok(fs.existsSync(path.join(personDir, 'responsibilities.md')), 'responsibilities.md missing');
+  assert.ok(fs.existsSync(path.join(personDir, 'contracts')), 'contracts/ missing');
+  assert.ok(fs.existsSync(path.join(personDir, 'contracts', 'ROOM.md')), 'contracts/ROOM.md missing');
+  console.log('ok test_create_speaker_profile_layout_import');
+
+  // Missing --role-bucket should exit 1.
+  const res2 = spawnSync('bash', [
+    scriptPath,
+    path.join(root, 'room'),
+    '--layout=import',
+    'bob-smith',
+    'Bob Smith'
+  ], { encoding: 'utf8' });
+  assert.notEqual(res2.status, 0, 'missing --role-bucket must fail');
+  console.log('ok test_create_speaker_profile_missing_role_bucket');
+})();
+
+console.log('ALL router tests passed');

package/lib/import/run-all-tests.cjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Zero-dep test runner for lib/import/*.test.cjs.
+ *
+ * Walks this directory, finds every *.test.cjs file, runs each in a child
+ * process (so module-level assert failures don't short-circuit the whole
+ * suite), reports pass/fail, and exits non-zero on any failure.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const dir = __dirname;
+const self = path.basename(__filename);
+const tests = fs
+  .readdirSync(dir)
+  .filter(function (f) { return f.endsWith('.test.cjs') && f !== self; })
+  .sort();
+
+let failed = 0;
+for (const t of tests) {
+  const full = path.join(dir, t);
+  const res = spawnSync(process.execPath, [full], { stdio: 'inherit' });
+  if (res.status === 0) {
+    process.stdout.write('PASS ' + t + '\n');
+  } else {
+    process.stderr.write('FAIL ' + t + ' (exit ' + res.status + ')\n');
+    failed += 1;
+  }
+}
+
+process.stdout.write('\n' + (tests.length - failed) + '/' + tests.length + ' test files passed\n');
+process.exit(failed === 0 ? 0 : 1);

package/lib/import/smoke-test.cjs

@@ -0,0 +1,213 @@
+'use strict';
+
+/**
+ * Phase 80 Plan 80-06 Task 2 (IMPORT-11) -- Post-import /mos: smoke test.
+ *
+ * After Stage 04 enrich completes, scripts/vault-import.cjs calls
+ * runMosSmokeTest(roomPath) to verify the room is immediately usable with
+ * /mos: commands. Deterministic: no AI, no network. Asserts at least one
+ * populated canonical section in the imported room.
+ *
+ * Execution pathway:
+ *   1. Try `node bin/mindrian-tools.cjs room state` (preferred)
+ *   2. If that fails OR PRECONDITIONS.md flags the lazygraph-ops issue,
+ *      fall back to `bash scripts/compute-state <roomPath>`
+ *   3. Parse the markdown output for the `## Sections` table:
+ *        | section | entries | ... |
+ *      and extract sectionCounts
+ *   4. If at least one canonical section has count > 0, passed = true
+ *
+ * Returns: { passed, sectionCounts, warnings, method }
+ *
+ * Hard rules:
+ *   - Never throws. All failure paths produce a structured result.
+ *   - Never mutates the room directory.
+ *   - No em-dashes anywhere in this file.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const CANONICAL_SECTIONS = [
+  'problem-definition',
+  'solution-design',
+  'business-model',
+  'market-analysis',
+  'competitive-analysis',
+  'financial-model',
+  'legal-ip',
+  'team-execution'
+];
+
+function pluginRootFromHere() {
+  return path.resolve(__dirname, '..', '..');
+}
+
+function readPreconditionsBroken(pluginRoot) {
+  const pre = path.join(pluginRoot, 'lib/import/PRECONDITIONS.md');
+  if (!fs.existsSync(pre)) return false;
+  try {
+    const txt = fs.readFileSync(pre, 'utf8');
+    return txt.includes('lazygraph-ops') && txt.includes('still broken');
+  } catch (e) {
+    return false;
+  }
+}
+
+// Parse compute-state markdown output. Looks for lines in the
+// `## Sections` table like `| problem-definition | 3 | ... |`.
+function parseSectionCounts(output) {
+  const counts = {};
+  if (!output) return counts;
+  const lines = output.split(/\r?\n/);
+  let inTable = false;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (/^##\s+Sections/.test(line)) { inTable = true; continue; }
+    if (inTable && /^##\s+/.test(line)) break;
+    if (!inTable) continue;
+    if (!line.startsWith('|')) continue;
+    if (/^\|\s*-+/.test(line)) continue;
+    if (/^\|\s*Section\s*\|/i.test(line)) continue;
+    const cells = line.split('|').map(function (c) { return c.trim(); }).filter(function (c) { return c.length > 0; });
+    if (cells.length < 2) continue;
+    const name = cells[0];
+    const n = parseInt(cells[1], 10);
+    if (name && !Number.isNaN(n)) counts[name] = n;
+  }
+  return counts;
+}
+
+function walkTeamCount(teamDir) {
+  if (!fs.existsSync(teamDir)) return 0;
+  let n = 0;
+  const stack = [teamDir];
+  while (stack.length) {
+    const d = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(d, { withFileTypes: true }); }
+    catch (e) { continue; }
+    for (const e of entries) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) stack.push(p);
+      else if (e.isFile() && e.name.endsWith('.md') && e.name !== 'ROOM.md' && e.name !== 'STATE.md') n++;
+    }
+  }
+  return n;
+}
+
+function runMosSmokeTest(roomPath, importContext) {
+  importContext = importContext || {};
+  const result = { passed: false, sectionCounts: {}, warnings: [], method: null };
+
+  if (!roomPath || !fs.existsSync(roomPath)) {
+    result.warnings.push('room path does not exist: ' + String(roomPath));
+    return result;
+  }
+
+  const pluginRoot = importContext.pluginRoot || pluginRootFromHere();
+  const lazyBroken = readPreconditionsBroken(pluginRoot);
+  const forceFallback = !!importContext.forceFallback;
+
+  let output = '';
+
+  // Attempt 1: bin/mindrian-tools.cjs room state
+  if (!forceFallback && !lazyBroken) {
+    const toolsPath = path.join(pluginRoot, 'bin/mindrian-tools.cjs');
+    if (fs.existsSync(toolsPath)) {
+      try {
+        output = execFileSync('node', [toolsPath, 'room', 'state'], {
+          cwd: roomPath,
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe']
+        });
+        result.method = 'mindrian-tools';
+      } catch (e) {
+        const msg = ((e && e.message) || '').slice(0, 160);
+        result.warnings.push('mindrian-tools room state failed: ' + msg);
+      }
+    }
+  }
+
+  // Attempt 2: scripts/compute-state fallback
+  if (!output) {
+    const computeState = path.join(pluginRoot, 'scripts/compute-state');
+    if (fs.existsSync(computeState)) {
+      try {
+        output = execFileSync('bash', [computeState, roomPath], {
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe']
+        });
+        result.method = 'compute-state';
+      } catch (e) {
+        const msg = ((e && e.message) || '').slice(0, 160);
+        result.warnings.push('compute-state failed: ' + msg);
+      }
+    } else {
+      result.warnings.push('compute-state script not found at ' + computeState);
+    }
+  }
+
+  // Parse whatever we got
+  if (output) {
+    const parsed = parseSectionCounts(output);
+    Object.assign(result.sectionCounts, parsed);
+  }
+
+  // Team count via filesystem walk (always, regardless of output)
+  const teamDir = path.join(roomPath, 'team');
+  if (fs.existsSync(teamDir)) {
+    const teamN = walkTeamCount(teamDir);
+    if (teamN > 0) result.sectionCounts.team = teamN;
+  }
+
+  // Pass/fail: at least one canonical section has count > 0
+  const populated = CANONICAL_SECTIONS.filter(function (s) { return (result.sectionCounts[s] || 0) > 0; });
+  if (populated.length === 0 && !(result.sectionCounts.team > 0)) {
+    result.warnings.push('no populated canonical sections');
+    result.passed = false;
+  } else {
+    result.passed = populated.length > 0;
+    if (!result.passed && result.sectionCounts.team > 0) {
+      // Team-only rooms pass with a warning.
+      result.passed = true;
+      result.warnings.push('only team populated; no canonical content sections');
+    }
+  }
+
+  return result;
+}
+
+function renderSmokeTestSection(result) {
+  const lines = [];
+  lines.push('## /mos: Usability Check');
+  lines.push('');
+  lines.push('- method: ' + (result.method || 'none'));
+  lines.push('- passed: ' + (result.passed ? 'true' : 'false'));
+  const populated = Object.entries(result.sectionCounts || {})
+    .filter(function (e) { return e[1] > 0; }).length;
+  lines.push('- populated sections: ' + populated);
+  lines.push('');
+  lines.push('### Section Counts');
+  const keys = Object.keys(result.sectionCounts || {});
+  if (keys.length === 0) {
+    lines.push('(none)');
+  } else {
+    for (const k of keys) lines.push('- ' + k + ': ' + result.sectionCounts[k]);
+  }
+  if ((result.warnings || []).length > 0) {
+    lines.push('');
+    lines.push('### Warnings');
+    for (const w of result.warnings) lines.push('- ' + w);
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+module.exports = {
+  runMosSmokeTest: runMosSmokeTest,
+  renderSmokeTestSection: renderSmokeTestSection,
+  parseSectionCounts: parseSectionCounts,
+  CANONICAL_SECTIONS: CANONICAL_SECTIONS
+};