@fiodos/cli 0.1.14 → 0.1.16

package/src/wireWeb.js

@@ -24,6 +24,10 @@ const {
   writeConsentDoc,
   agentJsx,
   envExpr,
+  registryRelImport,
+  addRegistriesToMountSource,
+  addRegistriesToBootstrapSource,
+  buildEntryBootstrapBlock,
   IMPORT_NAME,
   WRAPPER_BASENAME,
 } = require('./wireWebMount');
@@ -60,17 +64,24 @@ function firstExisting(appRoot, rels) {
 
 function detectTarget(appRoot, framework = detectFramework(appRoot)) {
   if (framework === 'vue') {
-    const f = firstExisting(appRoot, ['src/App.vue', 'src/main.ts', 'src/main.js']);
+    // Prefer the entry module (deterministic anchor → bootstrap injection). Fall
+    // back to the SFC <template> strategy only when there is no entry file.
+    const entry = firstExisting(appRoot, ['src/main.ts', 'src/main.js']);
+    if (entry) return { kind: 'vue-entry', file: entry, ext: path.extname(entry), framework };
+    const f = firstExisting(appRoot, ['src/App.vue']);
     return f ? { kind: 'vue', file: f, ext: path.extname(f), framework } : { kind: 'vue', file: null, framework };
   }
   if (framework === 'sveltekit') {
-    const f = firstExisting(appRoot, [
-      'src/routes/+layout.svelte', 'src/routes/+page.svelte', 'src/App.svelte',
-    ]);
-    return f ? { kind: 'sveltekit', file: f, ext: '.svelte', framework } : { kind: 'sveltekit', file: null, framework };
+    // SvelteKit owns the bootstrap (no src/main.ts), but src/hooks.client.ts runs
+    // once in the browser — the ideal, template-free spot. Create it if missing.
+    const existing = firstExisting(appRoot, ['src/hooks.client.ts', 'src/hooks.client.js']);
+    const file = existing || path.join(appRoot, 'src/hooks.client.ts');
+    return { kind: 'sveltekit-hooks', file, ext: path.extname(file), framework };
   }
   if (framework === 'svelte') {
-    const f = firstExisting(appRoot, ['src/App.svelte', 'src/routes/+layout.svelte', 'src/main.ts']);
+    const entry = firstExisting(appRoot, ['src/main.ts', 'src/main.js']);
+    if (entry) return { kind: 'svelte-entry', file: entry, ext: path.extname(entry), framework };
+    const f = firstExisting(appRoot, ['src/App.svelte']);
     return f ? { kind: 'svelte', file: f, ext: '.svelte', framework } : { kind: 'svelte', file: null, framework };
   }
   if (framework === 'angular') {
@@ -160,6 +171,15 @@ function printSnippet(target, framework, colors, appRoot, reason) {
     console.error(`${dim}Reason: ${reason}${reset}\n`);
   }
 
+  // Entry-file bootstrap frameworks: the safe fallback is the same one-shot call
+  // we would have auto-injected into the entry module — no <template> edit.
+  const entryKind = target && /(-entry|-hooks)$/.test(target.kind || '');
+  if (entryKind) {
+    const where = path.relative(appRoot, target.file);
+    console.error(`${dim}In ${where}, after your imports:${reset}\n`);
+    console.error(buildEntryBootstrapBlock());
+    return;
+  }
   if (framework === 'vue') {
     const where = target && target.file ? path.relative(appRoot, target.file) : 'src/App.vue';
     console.error(`${dim}In ${where}:${reset}\n`);
@@ -243,10 +263,23 @@ async function wireWebOrb(appRoot, opts = {}) {
   };
 
   const backups = backupFiles(plan.files);
+  // Files the installer creates from scratch (e.g. SvelteKit src/hooks.client.ts)
+  // are not in `backups`; a revert must DELETE them, not leave an orphan behind.
+  const createdFiles = plan.files.filter((f) => !(f in backups));
+  const revertAll = () => {
+    revertFiles(backups);
+    for (const f of createdFiles) {
+      try {
+        if (fs.existsSync(f)) fs.unlinkSync(f);
+      } catch {
+        /* best-effort */
+      }
+    }
+  };
   try {
     applyMount(plan);
     if (!verifyMounted(plan)) {
-      revertFiles(backups);
+      revertAll();
       printSnippet(target, framework, colors, appRoot, 'post-edit verification failed — FiodosAgent not found in edited files');
       return { status: 'failed', file: plan.rel };
     }
@@ -265,7 +298,7 @@ async function wireWebOrb(appRoot, opts = {}) {
         return { status: 'added', file: plan.rel, test };
       }
       // Build failed with the orb mounted — was the app building WITHOUT it?
-      revertFiles(backups);
+      revertAll();
       const baseline = await build();
       if (baseline.ok) {
         // Built before, fails now → the mount is the regression. Keep it reverted.
@@ -282,7 +315,7 @@ async function wireWebOrb(appRoot, opts = {}) {
     writeConsentDoc(appRoot, plan);
     return { status: 'added', file: plan.rel };
   } catch (err) {
-    revertFiles(backups);
+    revertAll();
     printSnippet(target, framework, colors, appRoot, err.message || String(err));
     return { status: 'failed', file: plan.rel, error: err };
   }
@@ -317,9 +350,121 @@ function reportWireResult(result, colors = {}, opts = {}) {
   }
 }
 
+/**
+ * Second pass (after handler wiring): connect the generated registry to the
+ * already-mounted orb so it EXECUTES actions, not just navigates. This is what
+ * removes the manual "paste registries={…}" step. Idempotent and reversible:
+ * the prop lives inside the FYODOS:ORB block. React-family mounts only —
+ * Vue/Svelte/Angular SDKs receive handlers differently and are left to the doc.
+ * Nav-only apps (no auto-wired handlers) never reach here (the caller gates on
+ * autoCount > 0), so they are not given a needless registries prop.
+ */
+function connectOrbRegistries(appRoot, opts = {}) {
+  const { registryFileAbs, exportName = 'fyodosGeneratedRegistries' } = opts;
+  if (!registryFileAbs || !fs.existsSync(registryFileAbs)) return { status: 'no-registry' };
+
+  const framework = detectFramework(appRoot);
+  const target = detectTarget(appRoot, framework);
+  if (!target || !target.file) return { status: 'no-target' };
+
+  // Entry-file bootstrap (Vue / Svelte / SvelteKit): the registries go INTO the
+  // createFiodosAgent({…}) call we injected into the entry module — same safe,
+  // idempotent, reversible block. No manual "pass registries" step anywhere.
+  const bootstrapKinds = new Set(['vue-entry', 'svelte-entry', 'sveltekit-hooks']);
+  if (bootstrapKinds.has(target.kind)) {
+    let source;
+    try {
+      source = fs.readFileSync(target.file, 'utf8');
+    } catch {
+      return { status: 'not-mounted' };
+    }
+    const importPath = registryRelImport(target.file, registryFileAbs);
+    const fileRel = path.relative(appRoot, target.file);
+    const backups = backupFiles([target.file]);
+    try {
+      const res = addRegistriesToBootstrapSource(source, importPath);
+      if (!res.changed) {
+        return { status: res.reason === 'already' ? 'already' : 'not-mounted', file: fileRel };
+      }
+      fs.writeFileSync(target.file, res.source);
+      return { status: 'connected', file: fileRel };
+    } catch (e) {
+      revertFiles(backups);
+      return { status: 'failed', file: fileRel, error: e };
+    }
+  }
+
+  // Only React-family mounts accept a `registries={...}` prop.
+  const reactKinds = new Set(['vite', 'next-pages', 'next-app']);
+  if (!reactKinds.has(target.kind)) return { status: 'unsupported-framework', framework };
+
+  // <FiodosAgent/> lives in the client wrapper for the Next App Router, in the
+  // entry/root file otherwise.
+  let mountFile = target.file;
+  if (target.kind === 'next-app') {
+    const dir = path.dirname(target.file);
+    mountFile =
+      [path.join(dir, `${WRAPPER_BASENAME}.tsx`), path.join(dir, `${WRAPPER_BASENAME}.jsx`)].find((f) =>
+        fs.existsSync(f),
+      ) || null;
+    if (!mountFile) return { status: 'not-mounted' };
+  }
+
+  let source;
+  try {
+    source = fs.readFileSync(mountFile, 'utf8');
+  } catch {
+    return { status: 'not-mounted' };
+  }
+  if (!/<FiodosAgent\b/.test(source)) return { status: 'not-mounted' };
+
+  const importPath = registryRelImport(mountFile, registryFileAbs);
+  const fileRel = path.relative(appRoot, mountFile);
+  const backups = backupFiles([mountFile]);
+  try {
+    const res = addRegistriesToMountSource(source, exportName, importPath);
+    if (!res.changed) {
+      return { status: res.reason === 'already' ? 'already' : 'not-mounted', file: fileRel };
+    }
+    fs.writeFileSync(mountFile, res.source);
+    return { status: 'connected', file: fileRel };
+  } catch (e) {
+    revertFiles(backups);
+    return { status: 'failed', file: fileRel, error: e };
+  }
+}
+
+function reportRegistriesResult(result, colors = {}, opts = {}) {
+  const quiet = opts.quiet !== false;
+  if (!result) return;
+  const { blue, cyan, dim, reset } = colors;
+  const tag = `${cyan || ''}◉${reset || ''} ${blue || ''}Fiodos${reset || ''}`;
+  switch (result.status) {
+    case 'connected':
+      console.error(`${tag} · ${dim || ''}connected actions to the orb (registries=) in ${result.file}${reset || ''}`);
+      break;
+    case 'already':
+      if (quiet) return;
+      console.error(`${tag} · ${dim || ''}orb already wired to actions in ${result.file}${reset || ''}`);
+      break;
+    case 'unsupported-framework':
+      console.error(`${tag} · ${dim || ''}pass the generated registry to your orb manually (see FYODOS_HANDLERS.md)${reset || ''}`);
+      break;
+    case 'failed':
+      console.error(`${tag} · ✗ could not auto-connect actions to the orb${result.file ? ` in ${result.file}` : ''}. See FYODOS_HANDLERS.md.`);
+      break;
+    default:
+      // not-mounted / no-registry / no-target: silent. The orb still navigates,
+      // and the doc shows how to connect actions by hand if needed.
+      break;
+  }
+}
+
 module.exports = {
   wireWebOrb,
   reportWireResult,
+  connectOrbRegistries,
+  reportRegistriesResult,
   detectFramework,
   detectTarget,
 };

package/src/wireWebMount.js

@@ -60,6 +60,75 @@ function insertImportAfterLastImport(source, importLine) {
   return lines.join('\n');
 }
 
+// Insert a multi-line block right after the last top-level import. The block may
+// itself contain import statements — placed after the existing ones they stay
+// valid top-level imports (ESM hoists them anyway). Used by the entry-file
+// bootstrap so the orb starts before the app mounts.
+function insertBlockAfterLastImport(source, block) {
+  const lines = source.split('\n');
+  let lastImport = -1;
+  for (let i = 0; i < lines.length; i += 1) {
+    if (/^\s*import\b/.test(lines[i])) lastImport = i;
+  }
+  if (lastImport === -1) return `${block}\n\n${source}`;
+  lines.splice(lastImport + 1, 0, '', block);
+  return lines.join('\n');
+}
+
+// ── Entry-file bootstrap (Vue / Svelte / SvelteKit) ───────────────────────────
+// Instead of editing a framework <template> (no deterministic anchor, fragile),
+// we inject a one-shot createFiodosAgent() call into the app's entry module
+// (src/main.ts, hooks.client.ts). The orb mounts itself to document.body, so it
+// never needs to live in the component tree. The whole call lives between
+// FYODOS:ORB markers → idempotent (re-runs strip & rewrite) and reversible.
+const BOOTSTRAP_ALIAS = '__fiodosCreateAgent';
+const BOOTSTRAP_REGISTRY_EXPORT = 'fyodosGeneratedRegistries';
+
+function buildEntryBootstrapBlock(opts = {}) {
+  const { registryImportPath } = opts;
+  const lines = [];
+  lines.push(ORB_SCRIPT_START);
+  lines.push(`import { createFiodosAgent as ${BOOTSTRAP_ALIAS} } from '@fiodos/web-core';`);
+  if (registryImportPath) {
+    lines.push(`import { ${BOOTSTRAP_REGISTRY_EXPORT} } from '${registryImportPath}';`);
+  }
+  lines.push(`${BOOTSTRAP_ALIAS}({`);
+  lines.push('  apiKey: import.meta.env.VITE_FYODOS_API_KEY,');
+  lines.push('  baseUrl: import.meta.env.VITE_FYODOS_API_URL,');
+  if (registryImportPath) lines.push(`  registries: ${BOOTSTRAP_REGISTRY_EXPORT},`);
+  lines.push('  mount: true,');
+  lines.push('});');
+  lines.push(ORB_SCRIPT_END);
+  return lines.join('\n');
+}
+
+function injectEntryBootstrap(plan, opts = {}) {
+  const file = plan.target.file;
+  let source = fs.existsSync(file) ? readFile(file) : '';
+  source = stripMarkedRegion(source, ORB_SCRIPT_START, ORB_SCRIPT_END).replace(/\n{3,}$/, '\n');
+  const block = buildEntryBootstrapBlock(opts);
+  let next;
+  if (!source.trim()) {
+    next = `${block}\n`;
+  } else {
+    next = insertBlockAfterLastImport(source, block);
+  }
+  writeFile(file, next.endsWith('\n') ? next : `${next}\n`);
+}
+
+// Idempotently rewrite an existing entry-bootstrap block to carry the generated
+// registries (second pass, after handler wiring). Returns { changed, source, reason? }.
+function addRegistriesToBootstrapSource(source, registryImportPath) {
+  if (!source.includes(ORB_SCRIPT_START)) return { changed: false, source, reason: 'not-mounted' };
+  if (/\n\s*registries:\s/.test(source.slice(source.indexOf(ORB_SCRIPT_START)))) {
+    return { changed: false, source, reason: 'already' };
+  }
+  const stripped = stripMarkedRegion(source, ORB_SCRIPT_START, ORB_SCRIPT_END).replace(/\n{3,}$/, '\n');
+  const block = buildEntryBootstrapBlock({ registryImportPath });
+  const next = insertBlockAfterLastImport(stripped.trimEnd(), block);
+  return { changed: true, source: next.endsWith('\n') ? next : `${next}\n` };
+}
+
 function envExpr(framework, kind, ts) {
   if (framework === 'vite' || framework === 'vue' || framework === 'svelte' || framework === 'sveltekit') {
     if (kind === 'key') {
@@ -87,6 +156,42 @@ function isAlreadyMounted(source) {
   return /FiodosAgent|fyodos-agent|FYODOS:ORB:START/.test(source);
 }
 
+// Import specifier (no extension, normalized slashes) from the file holding the
+// orb mount to the generated registry module.
+function registryRelImport(fromFile, registryAbs) {
+  let rel = path
+    .relative(path.dirname(fromFile), registryAbs)
+    .replace(/\\/g, '/')
+    .replace(/\.(tsx?|jsx?|mjs|cjs)$/, '');
+  if (!rel.startsWith('.')) rel = `./${rel}`;
+  return rel;
+}
+
+// Idempotently add `registries={EXPORT}` to the mounted <FiodosAgent/> and
+// import EXPORT from the generated registry. React-family mounts only. The prop
+// lands INSIDE the FYODOS:ORB block, so removing that block reverts it; the
+// import follows the existing FiodosAgent import convention (added once,
+// harmless if the block is later removed). Returns { changed, source, reason? }.
+function addRegistriesToMountSource(source, exportName, importPath) {
+  if (new RegExp(`registries=\\{${escapeRe(exportName)}\\}`).test(source)) {
+    return { changed: false, source, reason: 'already' };
+  }
+  const tagRe = /([ \t]*)<FiodosAgent\b[\s\S]*?\/>/;
+  const m = source.match(tagRe);
+  if (!m) return { changed: false, source, reason: 'not-mounted' };
+  const tag = m[0];
+  const baseIndent = m[1] || '';
+  const propMatch = tag.match(/\n([ \t]*)(?:apiKey|api-key|apiUrl|baseUrl)/);
+  const propIndent = propMatch ? propMatch[1] : `${baseIndent}  `;
+  const newTag = tag.replace(/\n?[ \t]*\/>$/, `\n${propIndent}registries={${exportName}}\n${baseIndent}/>`);
+  let next = source.replace(tag, newTag);
+  const importLine = `import { ${exportName} } from '${importPath}';`;
+  if (!next.includes(importLine)) {
+    next = insertImportAfterLastImport(next, importLine);
+  }
+  return { changed: true, source: next };
+}
+
 /**
  * Assess whether we can inject safely. Returns { ok, reason?, strategy, files, rel }.
  */
@@ -95,6 +200,19 @@ function assessMount(target, framework, appRoot) {
     return { ok: false, reason: 'could not locate a framework entry file (e.g. src/main.tsx, App.vue, +layout.svelte)' };
   }
   const rel = path.relative(appRoot, target.file);
+
+  // Entry-file bootstrap (Vue / Svelte / SvelteKit). The orb is injected into the
+  // app's entry module, not a <template>. For SvelteKit hooks the file may not
+  // exist yet — we create it (safe: a brand-new client hook only adds our block).
+  const entryKinds = new Set(['vue-entry', 'svelte-entry', 'sveltekit-hooks']);
+  if (entryKinds.has(target.kind)) {
+    const exists = fs.existsSync(target.file);
+    if (exists && isAlreadyMounted(readFile(target.file))) {
+      return { ok: false, reason: 'orb already present', already: true, rel };
+    }
+    return { ok: true, strategy: 'entry-bootstrap', files: [target.file], rel, framework, target, createIfMissing: !exists };
+  }
+
   const source = readFile(target.file);
   if (isAlreadyMounted(source)) {
     return { ok: false, reason: 'orb already present', already: true, rel };
@@ -105,14 +223,22 @@ function assessMount(target, framework, appRoot) {
       if (!source.includes('</body>')) {
         return { ok: false, reason: `${rel} has no </body> — cannot mount the orb wrapper safely` };
       }
-      return { ok: true, strategy: 'next-app', files: [target.file], rel, framework, target };
+      // The client wrapper we create lives next to the layout. Listing it in
+      // `files` means a revert DELETES it (it isn't in the backups) instead of
+      // leaving an orphan that imports @fiodos/react.
+      const ts = target.ext === '.tsx';
+      const wrapperFile = path.join(path.dirname(target.file), `${WRAPPER_BASENAME}${ts ? '.tsx' : '.jsx'}`);
+      return { ok: true, strategy: 'next-app', files: [target.file, wrapperFile], rel, framework, target };
     }
     case 'next-pages':
     case 'vite': {
       if (/createRoot\s*\(/.test(source) && /\.render\s*\(/.test(source)) {
         return { ok: true, strategy: 'vite-main', files: [target.file], rel, framework, target };
       }
-      if (/return\s*\([\s\S]*/.test(source)) {
+      // Accept any component that returns JSX — `return (` OR a bare `return <…/>`
+      // (the create-next-app default `_app.tsx`). We wrap the returned element in
+      // a fragment so the orb sits beside it without breaking adjacent-JSX rules.
+      if (/return\s*[<(]/.test(source)) {
         return { ok: true, strategy: 'react-return', files: [target.file], rel, framework, target };
       }
       return { ok: false, reason: `${rel} is not a recognizable React entry (no createRoot().render() or JSX return)` };
@@ -163,8 +289,13 @@ function resolveAngularTemplate(tsFile, tsSource) {
 }
 
 function describePlan(plan) {
-  const lines = [`Will edit: ${plan.files.map((f) => path.basename(f)).join(', ')}`];
+  const action = plan.createIfMissing ? 'Will create' : 'Will edit';
+  const lines = [`${action}: ${plan.files.map((f) => path.basename(f)).join(', ')}`];
   switch (plan.strategy) {
+    case 'entry-bootstrap':
+      lines.push('Add createFiodosAgent({ apiKey, baseUrl, mount }) after the imports');
+      lines.push('Orb self-mounts to document.body (no <template> edit, marked FYODOS:ORB:*)');
+      break;
     case 'next-app':
       lines.push(`Create ${WRAPPER_BASENAME} client wrapper next to layout`);
       lines.push(`Import wrapper and mount before </body>`);
@@ -262,6 +393,57 @@ function injectViteMain(plan) {
   writeFile(target.file, source);
 }
 
+// Wrap the component's last `return <jsx>` (with or without parentheses) in a
+// fragment that holds the original element AND the orb. Wrapping ANY single
+// returned expression as `<>{expr}{orb}</>` is always valid JSX, so this is the
+// universal, adjacent-JSX-safe fallback when there is no closing-tag anchor to
+// slot into (e.g. the create-next-app default `return <Component {...pageProps} />`).
+// Returns the new source, or null when no returnable JSX expression is found.
+function wrapLastReturnInFragment(source, orbJsx) {
+  const kw = /\breturn\b/g;
+  let m;
+  let retIdx = -1;
+  while ((m = kw.exec(source))) retIdx = m.index;
+  if (retIdx === -1) return null;
+
+  let i = retIdx + 'return'.length;
+  while (i < source.length && /\s/.test(source[i])) i += 1;
+  if (source[i] !== '(' && source[i] !== '<') return null;
+  const exprStart = i;
+
+  // Scan to the end of this one expression: stop at an unmatched ')' or '}'
+  // (the wrapping paren / function body) or a top-level ';'.
+  let round = 0;
+  let curly = 0;
+  let end = source.length;
+  for (let j = exprStart; j < source.length; j += 1) {
+    const c = source[j];
+    if (c === '(') round += 1;
+    else if (c === ')') {
+      if (round === 0) { end = j; break; }
+      round -= 1;
+    } else if (c === '{') curly += 1;
+    else if (c === '}') {
+      if (curly === 0) { end = j; break; }
+      curly -= 1;
+    } else if (c === ';' && round === 0 && curly === 0) { end = j; break; }
+  }
+
+  let expr = source.slice(exprStart, end).trim();
+  if (expr.startsWith('(') && expr.endsWith(')')) expr = expr.slice(1, -1).trim();
+  if (!expr) return null;
+
+  const ind = '    ';
+  const orbIndented = orbJsx
+    .split('\n')
+    .map((l) => (l ? `${ind}  ${l}` : l))
+    .join('\n');
+  const wrapped =
+    `(\n${ind}<>\n${ind}  ${expr}\n${orbIndented}\n${ind}</>\n${ind.slice(2)})`;
+
+  return source.slice(0, exprStart) + wrapped + source.slice(end);
+}
+
 function injectReactReturn(plan) {
   const { target, framework } = plan;
   const ts = target.ext === '.tsx';
@@ -281,12 +463,11 @@ function injectReactReturn(plan) {
       return;
     }
   }
-  const ret = source.lastIndexOf('return (');
-  if (ret === -1) throw new Error('no return ( found');
-  const close = source.indexOf(');', ret);
-  if (close === -1) throw new Error('no return close');
-  source = `${source.slice(0, close)}\n      ${orbBlock}\n    ${source.slice(close)}`;
-  writeFile(target.file, source);
+  // No closing-tag anchor (e.g. `return <Component {...pageProps} />`): wrap the
+  // returned element + orb in a fragment so adjacent JSX is always valid.
+  const wrapped = wrapLastReturnInFragment(source, orbBlock);
+  if (wrapped == null) throw new Error('no returnable JSX expression found');
+  writeFile(target.file, wrapped);
 }
 
 function injectVueSfc(plan) {
@@ -363,6 +544,9 @@ function injectAngularComponent(plan) {
 
 function applyMount(plan) {
   switch (plan.strategy) {
+    case 'entry-bootstrap':
+      injectEntryBootstrap(plan);
+      break;
     case 'next-app':
       injectNextApp(plan);
       break;
@@ -398,18 +582,17 @@ function writeConsentDoc(appRoot, plan) {
   const dir = path.join(appRoot, 'src', 'fyodos');
   fs.mkdirSync(dir, { recursive: true });
   const doc = [
-    '# Fiodos orb mount (auto-generated)',
+    '# Fiodos — orb mount',
     '',
-    `Date: ${new Date().toISOString()}`,
-    `Strategy: ${plan.strategy}`,
-    `Files edited:`,
-    ...plan.files.map((f) => `- ${path.relative(appRoot, f)}`),
+    'Mounts `<FiodosAgent />` in your app. The orb connects to the Fiodos backend',
+    'with your project API key and fetches its manifest and appearance on its own;',
+    'nothing else to paste.',
     '',
-    'Changes are wrapped in FYODOS:ORB:START / FYODOS:ORB:END markers.',
-    'Remove those blocks (and the Fiodos import) to revert manually.',
+    `- Strategy: \`${plan.strategy}\``,
+    `- Files: ${plan.files.map((f) => `\`${path.relative(appRoot, f)}\``).join(', ')}`,
     '',
-    'Planned edits:',
-    ...describePlan(plan).map((l) => `- ${l}`),
+    'Edits sit between `FYODOS:ORB:START` / `FYODOS:ORB:END` markers. Remove those',
+    'blocks (and the Fiodos import) to revert.',
     '',
   ].join('\n');
   writeFile(path.join(dir, 'FYODOS_ORB_MOUNT.md'), doc);
@@ -430,6 +613,10 @@ module.exports = {
   revertFiles,
   writeConsentDoc,
   isAlreadyMounted,
+  registryRelImport,
+  addRegistriesToMountSource,
+  addRegistriesToBootstrapSource,
+  buildEntryBootstrapBlock,
   IMPORT_NAME,
   WRAPPER_BASENAME,
 };