@fiodos/cli 0.1.25 → 0.1.26

package/src/wireScreen.js

@@ -0,0 +1,562 @@
+/**
+ * wireScreen — automatic SCREEN-TRUTH wiring for apps whose screens are NOT
+ * URLs. NO MANUAL STEP.
+ *
+ * WHY: the orb resolves "where is the user right now" from
+ * `navigation.getCurrentRoute()` — on the web that is the pathname. Many apps
+ * switch screens through CLIENT STATE instead (a `useState` section switcher,
+ * tabs, a dashboard shell): the URL never changes, so the orb is blind — the
+ * per-screen bubble never updates, "you are already there" detection fails and
+ * screen-scoped context is wrong. This module closes that gap exactly like
+ * session wiring closed the auth gap: the SAME AI that read the app's code
+ * says WHERE the active-screen state lives, a mechanical verifier confirms
+ * every referenced symbol exists, the edit is applied under the same consent,
+ * and a build check reverts it if anything regressed.
+ *
+ * WHAT IT PRODUCES:
+ *   · `src/fyodos/screen.generated.<ext>` exporting:
+ *       - fyodosGetCurrentScreen(): string | null  (the app-reported active
+ *         screen key, or null when unknown/stale)
+ *       - fyodosGetCurrentRoute(): string | null   (URL-shaped current route
+ *         COMBINING pathname + reported screen — what the orb mount consumes
+ *         as `getCurrentRoute`)
+ *   · A tiny reversible registration in the component that OWNS the screen
+ *     state (markers FYODOS:SCREEN:START/END): on every render it re-registers
+ *     a getter closing over the CURRENT screen value, plus the pathname where
+ *     the report was made — so a report from another page is mechanically
+ *     detected as stale and ignored (truth of screen, never a stale claim).
+ *
+ * HONESTY:
+ *   · Unknown beats wrong: when the owning component has not rendered (or the
+ *     user left that page), the module returns the plain pathname — exactly
+ *     today's behavior, never a stale screen claim.
+ *   · Everything the AI proposed is verified mechanically before writing;
+ *     unverifiable → an honest 'review' report, never a blind write.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  fileHasSymbol,
+  freeIdentifiers,
+  declaredLocals,
+  detachedInstanceReceiver,
+  countOccurrences,
+  readFileSafe,
+  normRel,
+  relImport,
+  detectTsEsm,
+  resolveFiodosDirRel,
+  askYesNo,
+  JS_KEYWORDS,
+  SAFE_GLOBALS,
+  GENERATED_FILE_DIRECTIVES,
+  INJECT_ESLINT_DISABLE,
+  INJECT_ESLINT_ENABLE,
+  BRIDGE_BASENAME,
+  buildBridgeModule,
+  insertImportBlock,
+  insertRegisterBlock,
+  deriveBridgeAnchor,
+} = require('./wireHandlers');
+
+const SCREEN_BASENAME = 'screen.generated';
+const DOC_BASENAME = 'FYODOS_SCREEN.md';
+const SCREEN_EXPORT = 'fyodosGetCurrentScreen';
+const ROUTE_EXPORT = 'fyodosGetCurrentRoute';
+const BRIDGE_SCREEN = '__fyodos_screen';
+
+// Own markers: wireHandlers strips FYODOS:BRIDGE blocks and wireSession strips
+// FYODOS:SESSION blocks — sharing either would make a re-run of one silently
+// delete the other's registration in the same component.
+const SCREEN_EDIT_START_PREFIX = '// FYODOS:SCREEN:START';
+const SCREEN_EDIT_START = `${SCREEN_EDIT_START_PREFIX} (generated by Fiodos — safe to remove)`;
+const SCREEN_EDIT_END = '// FYODOS:SCREEN:END';
+
+function esc(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** Remove previously-inserted screen blocks (idempotence across re-runs). */
+function stripScreenBlocks(content) {
+  const re = new RegExp(
+    `\\n?${esc(SCREEN_EDIT_START_PREFIX)}[^\\n]*[\\s\\S]*?${esc(SCREEN_EDIT_END)}\\n?`,
+    'g',
+  );
+  return content.replace(re, '\n');
+}
+
+// ── Mechanical verification of the AI's screen proposal ────────────────────────
+
+function verifyImports({ appRoot, rawImports, importBaseDirRel }) {
+  const imports = [];
+  const importedNames = new Set();
+  for (const imp of Array.isArray(rawImports) ? rawImports : []) {
+    const name = String((imp && imp.name) || '').trim();
+    const from = normRel(imp && imp.from);
+    const kind = (imp && imp.kind) || 'named';
+    if (!name || !from) return { reason: 'a screen import is incomplete (missing name/from)' };
+    if (!fs.existsSync(path.join(appRoot, from))) {
+      return { reason: `the screen import points to a non-existent file: '${from}'` };
+    }
+    if (kind === 'named' && !fileHasSymbol(appRoot, from, name)) {
+      return { reason: `named import '${name}' does not exist in '${from}'` };
+    }
+    imports.push({ kind, name, importPath: relImport(importBaseDirRel, from) });
+    importedNames.add(name);
+  }
+  return { imports, importedNames };
+}
+
+function verifyExpr({ expr, importedNames, extraOk = new Set() }) {
+  const detached = detachedInstanceReceiver(expr);
+  if (detached) {
+    return `the screen expression instantiates '${detached}' with 'new' and uses it as the receiver; a fresh instance is disconnected from the app's real screen state`;
+  }
+  const locals = declaredLocals(expr);
+  for (const id of freeIdentifiers(expr)) {
+    if (JS_KEYWORDS.has(id) || SAFE_GLOBALS.has(id) || importedNames.has(id) || locals.has(id) || extraOk.has(id)) {
+      continue;
+    }
+    return `the screen expression references '${id}', which could not be verified in your code`;
+  }
+  return null;
+}
+
+/**
+ * Turn the AI's `screen` block into a verified plan, or { none } / { reason }.
+ * Plan shape: { bridge: { file, anchor, scope, imports, screenInvoke } }.
+ * (`kind: 'url'` — or no block at all — means screens ARE URLs and nothing
+ * needs wiring: today's pathname behavior is already the truth.)
+ */
+function prepareScreenPlan({ appRoot, screen, fyodosDirRel }) {
+  if (!screen || typeof screen !== 'object') {
+    return { none: true, reason: 'no screen block — screens are assumed URL-driven' };
+  }
+  if (screen.kind !== 'state') {
+    return { none: true, reason: String(screen.reason || 'screens are URL-driven') };
+  }
+
+  const required = Array.isArray(screen.requiredSymbols) ? screen.requiredSymbols : [];
+  for (const r of required) {
+    if (!fileHasSymbol(appRoot, r && r.file, r && r.name)) {
+      return {
+        reason: `the verifier did not find symbol '${r && r.name}' in '${normRel(r && r.file)}'`,
+      };
+    }
+  }
+
+  const b = screen.bridge || {};
+  const file = normRel(b.file);
+  let anchor = String(b.anchor || '').trim();
+  const screenInvoke = String(b.screenInvoke || '').trim();
+
+  if (!file) return { reason: 'the AI marked state-driven screens but gave no component file' };
+  const content = readFileSafe(appRoot, file);
+  if (content == null) return { reason: `could not read the component '${file}'` };
+  if (!screenInvoke) return { reason: `no screen expression was provided for '${file}'` };
+
+  // Anchor ladder: exact-unique AI anchor, else derive one deterministically
+  // from the declaration of the symbol the invoke reads (same rescue as
+  // handler/session bridges). Never wire on an ambiguous insertion point.
+  const cleanContent = stripScreenBlocks(content);
+  const occ = anchor ? countOccurrences(cleanContent, anchor) : 0;
+  if (occ !== 1) {
+    const derived = deriveBridgeAnchor(cleanContent, screenInvoke);
+    if (derived) anchor = derived;
+    else if (!anchor || occ === 0) return { reason: `no safe insertion point was found in '${file}'` };
+    else return { reason: `the insertion anchor appears ${occ} times in '${file}'; it is ambiguous` };
+  }
+
+  const v = verifyImports({ appRoot, rawImports: b.imports, importBaseDirRel: path.dirname(file) });
+  if (v.reason) return v;
+
+  const inFileOk = new Set();
+  for (const id of freeIdentifiers(screenInvoke)) {
+    if (fileHasSymbol(appRoot, file, id)) inFileOk.add(id);
+  }
+  const err = verifyExpr({ expr: screenInvoke, importedNames: v.importedNames, extraOk: inFileOk });
+  if (err) return { reason: `${err} — in '${file}'` };
+
+  return {
+    plan: {
+      reason: String(screen.reason || ''),
+      bridge: {
+        file,
+        anchor,
+        scope: b.scope === 'class-field' ? 'class-field' : 'statement',
+        imports: v.imports,
+        screenInvoke,
+        importPathToBridge: relImport(path.dirname(file), path.join(fyodosDirRel, BRIDGE_BASENAME)),
+      },
+    },
+  };
+}
+
+// ── Codegen ─────────────────────────────────────────────────────────────────────
+
+function importLine(imp, esm) {
+  if (!esm) return `const { ${imp.name} } = require('${imp.importPath}');`;
+  if (imp.kind === 'default') return `import ${imp.name} from '${imp.importPath}';`;
+  if (imp.kind === 'namespace') return `import * as ${imp.name} from '${imp.importPath}';`;
+  return `import { ${imp.name} } from '${imp.importPath}';`;
+}
+
+/**
+ * The generated screen module. Contract with the SDK:
+ *   - fyodosGetCurrentScreen(): the app-reported screen key, or null when the
+ *     owning component has not rendered OR the report was made on a DIFFERENT
+ *     page (stale) — unknown beats wrong.
+ *   - fyodosGetCurrentRoute(): a URL-shaped route the orb consumes directly:
+ *     pathname when no fresh screen report exists, pathname + screen key when
+ *     one does (e.g. '/dashboard' + 'agente' → '/dashboard/agente', matching
+ *     the manifest's route strings exactly).
+ */
+function buildScreenModule(opts = {}) {
+  const ts = opts.ts !== false;
+  const esm = opts.esm !== false;
+  const strRet = ts ? ': string | null' : '';
+
+  const L = [];
+  L.push(
+    `${GENERATED_FILE_DIRECTIVES}/** GENERATED by Fiodos — screen-truth wiring. Do not edit — re-run the Fiodos installer to regenerate. */`,
+  );
+  L.push('');
+  L.push(
+    esm
+      ? `import { getFiodosBridge } from './${BRIDGE_BASENAME}';`
+      : `const { getFiodosBridge } = require('./${BRIDGE_BASENAME}');`,
+  );
+  L.push('');
+  L.push('/**');
+  L.push(' * The ACTIVE screen key the app itself reported (state-driven screens), or');
+  L.push(' * null when unknown. A report made on a DIFFERENT page than the current one');
+  L.push(' * is stale and ignored — the orb must never act on a screen claim that is');
+  L.push(' * no longer true.');
+  L.push(' */');
+  L.push(`export function ${SCREEN_EXPORT}()${strRet} {`);
+  L.push('  try {');
+  L.push(`    const fn = getFiodosBridge()[${JSON.stringify(BRIDGE_SCREEN)}];`);
+  L.push("    if (typeof fn !== 'function') return null;");
+  L.push('    const s = fn();');
+  L.push("    if (!s || typeof s !== 'object') return null;");
+  L.push("    const value = s.value == null || s.value === '' ? null : String(s.value);");
+  L.push('    if (value == null) return null;');
+  L.push("    const here = typeof window !== 'undefined' && window.location ? window.location.pathname : null;");
+  L.push('    const at = s.path == null ? null : String(s.path);');
+  L.push('    if (at != null && here != null && at !== here) return null;');
+  L.push('    return value;');
+  L.push('  } catch {');
+  L.push('    return null;');
+  L.push('  }');
+  L.push('}');
+  L.push('');
+  L.push('/** URL-shaped current route for the orb: pathname + the reported screen key. */');
+  L.push(`export function ${ROUTE_EXPORT}()${strRet} {`);
+  L.push('  try {');
+  L.push("    const base = typeof window !== 'undefined' && window.location ? window.location.pathname : null;");
+  L.push(`    const screen = ${SCREEN_EXPORT}();`);
+  L.push('    if (screen == null) {');
+  L.push("      return base == null ? null : base + (window.location.search || '');");
+  L.push('    }');
+  L.push("    const key = screen.replace(/^\\/+|\\/+$/g, '');");
+  L.push("    if (base == null || base === '' || base === '/') return '/' + key;");
+  L.push("    const trimmed = base.replace(/\\/+$/, '');");
+  L.push("    if (trimmed.toLowerCase().endsWith('/' + key.toLowerCase())) return trimmed;");
+  L.push("    return trimmed + '/' + key;");
+  L.push('  } catch {');
+  L.push('    return null;');
+  L.push('  }');
+  L.push('}');
+  L.push('');
+  if (!esm) L.push(`module.exports = { ${SCREEN_EXPORT}, ${ROUTE_EXPORT} };`);
+  let body = L.join('\n');
+  if (!esm) {
+    body = body.replace(/^export function /gm, 'function ');
+  }
+  return `${body}\n`;
+}
+
+/** Plan the reversible edit inserted into the screen-owning component. */
+function planScreenComponentEdit(appRoot, plan) {
+  const b = plan.bridge;
+  const content = readFileSafe(appRoot, b.file) || '';
+
+  // The getter is re-registered on EVERY render, so its closure always holds
+  // the CURRENT screen value; the IIFE captures the pathname at render time so
+  // the generated module can detect stale reports from another page.
+  const pathExpr =
+    "typeof window !== 'undefined' && window.location ? window.location.pathname : null";
+  const getter = `((p) => () => ({ value: (${b.screenInvoke}), path: p }))(${pathExpr})`;
+  const methods = [`  ${JSON.stringify(BRIDGE_SCREEN)}: ${getter},`];
+
+  const importLines = [`import { registerFiodosBridge } from '${b.importPathToBridge}';`];
+  for (const imp of b.imports || []) importLines.push(importLine(imp, true));
+
+  const registerCall =
+    b.scope === 'class-field'
+      ? `private __fyodosScreenBridge = registerFiodosBridge({\n${methods.join('\n')}\n});`
+      : `registerFiodosBridge({\n${methods.join('\n')}\n});`;
+
+  const anchorIdx = content.indexOf(b.anchor);
+  const lineStart = content.lastIndexOf('\n', anchorIdx) + 1;
+  const indent = (content.slice(lineStart, anchorIdx).match(/^\s*/) || [''])[0];
+  const registerBlock = `${SCREEN_EDIT_START}\n${INJECT_ESLINT_DISABLE}\n${registerCall}\n${INJECT_ESLINT_ENABLE}\n${SCREEN_EDIT_END}`;
+
+  return {
+    file: b.file,
+    anchor: b.anchor,
+    scope: b.scope,
+    importBlock: `${SCREEN_EDIT_START}\n${INJECT_ESLINT_DISABLE}\n${importLines.join('\n')}\n${INJECT_ESLINT_ENABLE}\n${SCREEN_EDIT_END}`,
+    registerBlock: registerBlock
+      .split('\n')
+      .map((l) => (l ? indent + l : l))
+      .join('\n'),
+  };
+}
+
+/** True when the (TS/JS/TSX/JSX) source still parses. Fail-open without esbuild. */
+function parsesOk(source, file) {
+  if (file.endsWith('.vue') || file.endsWith('.svelte')) return true;
+  try {
+    const esbuild = require('esbuild');
+    const loader = /\.tsx$/.test(file) ? 'tsx' : /\.jsx$/.test(file) ? 'jsx' : /\.ts$/.test(file) ? 'ts' : 'js';
+    esbuild.transformSync(source, { loader });
+    return true;
+  } catch (e) {
+    if (e && e.code === 'MODULE_NOT_FOUND') return true;
+    return false;
+  }
+}
+
+/** Apply the screen component edit (idempotent, snapshot for revert). */
+function applyScreenComponentEdit(appRoot, edit) {
+  const abs = path.join(appRoot, normRel(edit.file));
+  const original = fs.readFileSync(abs, 'utf8');
+  let next = stripScreenBlocks(original);
+  next = insertImportBlock(next, edit.importBlock);
+  next = insertRegisterBlock(next, edit.file, edit.anchor, edit.registerBlock, edit.scope);
+  if (!parsesOk(next, edit.file)) {
+    throw new Error(`the screen registration would break '${edit.file}' (parse check failed)`);
+  }
+  fs.writeFileSync(abs, next);
+  return { file: edit.file, abs, original };
+}
+
+// ── Document ────────────────────────────────────────────────────────────────────
+
+function buildScreenDoc(plan, ctx = {}) {
+  const { appName = 'your app', screenRel = '', editedFile = '', verified = false, verifyNote = '' } = ctx;
+  const L = [];
+  L.push('# Fiodos — screen-truth wiring (state-driven screens)');
+  L.push('');
+  L.push('Your app switches screens through CLIENT STATE (the URL does not change), so');
+  L.push('the orb cannot tell where the user is from the pathname alone. This wiring');
+  L.push('reports the ACTIVE screen to the orb automatically: the per-screen bubble,');
+  L.push('"you are already there" detection and screen-scoped context all work.');
+  L.push('');
+  L.push(`- App: \`${appName}\``);
+  L.push(`- Why: ${plan.reason || 'the active screen lives in component state'}`);
+  L.push(`- Creates \`${screenRel}\` — exports \`${SCREEN_EXPORT}()\` and \`${ROUTE_EXPORT}()\`.`);
+  if (editedFile) {
+    L.push(`- Edits \`${editedFile}\` (only reversible \`FYODOS:SCREEN\` blocks) to report the live screen.`);
+  }
+  L.push(`- Verification: ${verified ? 'build check passed' : verifyNote || 'compile check unavailable — applied with the mechanical symbol verification only'}.`);
+  L.push('');
+  L.push('## Honesty contract');
+  L.push('');
+  L.push('The report carries the pathname where it was made: when the user moves to a');
+  L.push('different page, the stale report is ignored and the orb falls back to the');
+  L.push('plain pathname — it never acts on a screen claim that is no longer true.');
+  L.push('');
+  L.push('Remove the generated file and the `FYODOS:SCREEN` blocks to revert entirely.');
+  L.push('');
+  return L.join('\n');
+}
+
+// ── Main entry ──────────────────────────────────────────────────────────────────
+
+/**
+ * Wire screen truth automatically. Options mirror wireSession. Returns
+ * { status, screenFile?, docPath?, editedFile?, reason? } with status in:
+ * 'applied' | 'applied-untested' | 'url-screens' | 'review' | 'declined' |
+ * 'reverted' | 'skipped'.
+ */
+async function wireScreen(appRoot, opts = {}) {
+  const {
+    screen,
+    colors = {},
+    quiet = false,
+    assumeYes = false,
+    noWire = false,
+    framework = 'web',
+    appName,
+    runTest = false,
+    testRunner = null,
+    ts: tsOpt,
+    esm: esmOpt,
+  } = opts;
+  const { blue, cyan, dim, reset } = colors;
+  const tag = `${cyan || ''}◉${reset || ''} ${blue || ''}Fiodos${reset || ''}`;
+
+  if (noWire) return { status: 'skipped', reason: 'no-wire' };
+
+  const fyodosDirRel = resolveFiodosDirRel(appRoot);
+  const fyodosDirAbs = path.join(appRoot, fyodosDirRel);
+  const detected = detectTsEsm(appRoot);
+  const ts = tsOpt != null ? tsOpt : detected.ts;
+  const esm = esmOpt != null ? esmOpt : detected.esm;
+  const ext = ts ? '.ts' : esm ? '.js' : '.cjs';
+
+  const prep = prepareScreenPlan({ appRoot, screen, fyodosDirRel });
+  if (prep.none) return { status: 'url-screens', reason: prep.reason };
+  if (!prep.plan) {
+    if (!quiet) {
+      console.error(`${tag} · ${dim || ''}Screen wiring left for review: ${prep.reason}${reset || ''}`);
+    }
+    return { status: 'review', reason: prep.reason };
+  }
+  const plan = prep.plan;
+
+  if (!assumeYes) {
+    if (!process.stdin.isTTY) return { status: 'declined', reason: 'non-interactive' };
+    const yes = await askYesNo(
+      `\n${tag} · Report the app's ACTIVE screen to the orb automatically (registers it from \`${plan.bridge.file}\`)? [yes/no] `,
+    );
+    if (!yes) return { status: 'declined' };
+  }
+
+  let baseline = null;
+  if (runTest && testRunner) {
+    try {
+      baseline = await testRunner(appRoot, { framework });
+    } catch (err) {
+      baseline = { ok: false, stage: 'runner', output: err && err.message };
+    }
+  }
+
+  fs.mkdirSync(fyodosDirAbs, { recursive: true });
+  const screenAbs = path.join(fyodosDirAbs, `${SCREEN_BASENAME}${ext}`);
+  const bridgeAbs = path.join(fyodosDirAbs, `${BRIDGE_BASENAME}${ext}`);
+  const generated = [screenAbs];
+  let backups = [];
+  let bridgeCreatedByUs = false;
+
+  try {
+    if (!fs.existsSync(bridgeAbs)) {
+      fs.writeFileSync(bridgeAbs, buildBridgeModule({ ts, esm }));
+      bridgeCreatedByUs = true;
+      generated.push(bridgeAbs);
+    }
+    fs.writeFileSync(screenAbs, buildScreenModule({ ts, esm }));
+    const edit = planScreenComponentEdit(appRoot, plan);
+    backups = [applyScreenComponentEdit(appRoot, edit)];
+  } catch (err) {
+    for (const b of backups) fs.writeFileSync(b.abs, b.original);
+    for (const f of generated) {
+      try {
+        if (fs.existsSync(f)) fs.rmSync(f);
+      } catch {
+        /* best effort */
+      }
+    }
+    return { status: 'reverted', reason: err && err.message };
+  }
+
+  let verified = false;
+  let verifyNote = '';
+  if (runTest && testRunner) {
+    let after;
+    try {
+      after = await testRunner(appRoot, { framework });
+    } catch (err) {
+      after = { ok: false, stage: 'runner', output: err && err.message };
+    }
+    if (after && after.ok) {
+      verified = true;
+    } else if (baseline && baseline.ok) {
+      for (const b of backups) fs.writeFileSync(b.abs, b.original);
+      for (const f of generated) {
+        try {
+          if (fs.existsSync(f)) fs.rmSync(f);
+        } catch {
+          /* best effort */
+        }
+      }
+      if (!quiet) {
+        console.error(
+          `${tag} · ${dim || ''}Screen wiring reverted: the app stopped compiling with it applied.${reset || ''}`,
+        );
+      }
+      return { status: 'reverted', reason: 'compile regression', output: after && after.output };
+    } else {
+      verifyNote = 'the app did not compile BEFORE wiring either — applied; symbols were verified mechanically';
+    }
+  }
+
+  const docAbs = path.join(fyodosDirAbs, DOC_BASENAME);
+  const screenRel = path.relative(appRoot, screenAbs).split(path.sep).join('/');
+  fs.writeFileSync(
+    docAbs,
+    buildScreenDoc(plan, {
+      appName: appName || path.basename(appRoot),
+      screenRel,
+      editedFile: plan.bridge.file,
+      verified,
+      verifyNote,
+    }),
+  );
+
+  return {
+    status: verified ? 'applied' : 'applied-untested',
+    screenFile: screenAbs,
+    docPath: docAbs,
+    editedFile: plan.bridge.file,
+    bridgeCreated: bridgeCreatedByUs,
+  };
+}
+
+function reportScreenResult(result, colors = {}, { quiet = false } = {}) {
+  if (!result) return;
+  const { blue, cyan, dim, reset } = colors;
+  const tag = `${cyan || ''}◉${reset || ''} ${blue || ''}Fiodos${reset || ''}`;
+  switch (result.status) {
+    case 'applied':
+      console.error(`${tag} · screen truth connected automatically — the orb now knows which screen the user is on even without URL changes`);
+      break;
+    case 'applied-untested':
+      console.error(`${tag} · screen truth connected (compile check unavailable)`);
+      break;
+    case 'review':
+      console.error(`${tag} · ${dim || ''}screen wiring left for review: ${result.reason}${reset || ''}`);
+      break;
+    case 'reverted':
+      console.error(`${tag} · ${dim || ''}screen wiring reverted (${result.reason})${reset || ''}`);
+      break;
+    case 'url-screens':
+      if (!quiet) console.error(`${tag} · ${dim || ''}screens are URL-driven — no screen wiring needed${reset || ''}`);
+      break;
+    default:
+      break;
+  }
+}
+
+module.exports = {
+  wireScreen,
+  reportScreenResult,
+  // exported for tests
+  prepareScreenPlan,
+  buildScreenModule,
+  buildScreenDoc,
+  planScreenComponentEdit,
+  applyScreenComponentEdit,
+  stripScreenBlocks,
+  SCREEN_BASENAME,
+  SCREEN_EXPORT,
+  ROUTE_EXPORT,
+  BRIDGE_SCREEN,
+  SCREEN_EDIT_START,
+  SCREEN_EDIT_END,
+};