@shanyucoder/flowgrid 0.1.4 → 0.1.8

package/engines/registry-sync/be-capabilities-sync.mjs

@@ -0,0 +1,118 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const REGISTRY_REL = 'registries/be-capabilities.registry.json';
+
+const BE_SCAN_RULES = {
+  laravel: [
+    { kind: 'exceptionHandler', globs: ['app/Exceptions/Handler.php'], tags: ['#err:validation', '#err:not-found', '#err:permission-denied'] },
+    { kind: 'middleware', dir: 'app/Http/Middleware', tags: ['#api: middleware'] },
+    { kind: 'helpers', dir: 'app/Support', tags: ['#helper: support'] },
+    { kind: 'helpers', dir: 'app/Helpers', tags: ['#helper: app'] },
+    { kind: 'auth', globs: ['app/Http/Controllers/Controller.php', 'routes/api.php'], tags: ['#api: auth'] },
+  ],
+  nestjs: [
+    { kind: 'exceptionHandler', globs: ['src/common/filters/http-exception.filter.ts', 'src/filters/http-exception.filter.ts'], tags: ['#err:validation'] },
+    { kind: 'middleware', dir: 'src/common/middleware', tags: ['#api: middleware'] },
+    { kind: 'auth', globs: ['src/auth/auth.guard.ts', 'src/common/guards/jwt-auth.guard.ts'], tags: ['#api: auth', '#err:permission-denied'] },
+    { kind: 'helpers', dir: 'src/common', tags: ['#helper: common'] },
+  ],
+  fastapi: [
+    { kind: 'exceptionHandler', globs: ['app/core/exceptions.py', 'app/exceptions.py'], tags: ['#err:validation'] },
+    { kind: 'middleware', dir: 'app/middleware', tags: ['#api: middleware'] },
+    { kind: 'auth', globs: ['app/core/security.py', 'app/auth/deps.py'], tags: ['#api: auth'] },
+  ],
+};
+
+function loadJson(abs, fallback) {
+  if (!fs.existsSync(abs)) return fallback;
+  try {
+    return JSON.parse(fs.readFileSync(abs, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function listFilesInDir(root, relDir, max = 80) {
+  const dir = path.join(root, relDir);
+  if (!fs.existsSync(dir)) return [];
+  const out = [];
+  const walk = (d, depth) => {
+    if (depth > 4 || out.length >= max) return;
+    for (const ent of fs.readdirSync(d, { withFileTypes: true })) {
+      const full = path.join(d, ent.name);
+      if (ent.isDirectory()) walk(full, depth + 1);
+      else if (/\.(php|ts|py)$/.test(ent.name)) {
+        out.push(path.relative(root, full).split(path.sep).join('/'));
+      }
+    }
+  };
+  walk(dir, 0);
+  return out;
+}
+
+/**
+ * @param {string} projectRoot
+ * @param {string} beAdapter
+ * @param {string} packageRoot
+ * @param {{ dryRun?: boolean }} opts
+ */
+export function syncBeCapabilitiesRegistry(projectRoot, beAdapter, packageRoot, opts = {}) {
+  const rules = BE_SCAN_RULES[beAdapter] ?? BE_SCAN_RULES.laravel;
+  const registryPath = path.join(projectRoot, REGISTRY_REL);
+  const baseTemplate = path.join(packageRoot, 'templates/shared/be-capabilities.registry.base.json');
+  const registry = loadJson(registryPath, loadJson(baseTemplate, { version: 1, capabilities: {} }));
+
+  const capabilities = { ...(registry.capabilities ?? {}) };
+  const middleware = [];
+  const exceptionHandlers = [];
+  const helpers = [];
+
+  for (const rule of rules) {
+    if (rule.globs) {
+      for (const g of rule.globs) {
+        const abs = path.join(projectRoot, g);
+        if (!fs.existsSync(abs)) continue;
+        const entry = { path: g, tags: rule.tags, kind: rule.kind };
+        capabilities[g] = entry;
+        if (rule.kind === 'exceptionHandler') exceptionHandlers.push(entry);
+        else if (rule.kind === 'auth') helpers.push(entry);
+      }
+    }
+    if (rule.dir) {
+      const files = listFilesInDir(projectRoot, rule.dir);
+      for (const f of files) {
+        const entry = { path: f, tags: rule.tags, kind: rule.kind };
+        capabilities[f] = entry;
+        if (rule.kind === 'middleware') middleware.push(entry);
+        else helpers.push(entry);
+      }
+    }
+  }
+
+  const merged = {
+    ...registry,
+    adapter: beAdapter,
+    capabilities,
+    middleware,
+    exceptionHandlers,
+    helpers,
+    scannedAt: new Date().toISOString(),
+  };
+
+  const report = {
+    registryPath: REGISTRY_REL,
+    capabilityKeys: Object.keys(capabilities).length,
+    middleware: middleware.length,
+    exceptionHandlers: exceptionHandlers.length,
+  };
+
+  if (opts.dryRun) {
+    return { ok: true, dryRun: true, report, registry: merged };
+  }
+
+  const dir = path.dirname(registryPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(registryPath, JSON.stringify(merged, null, 2) + '\n');
+  return { ok: true, report, registryPath };
+}

package/engines/registry-sync/fe-design-sync.mjs

@@ -0,0 +1,258 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const REGISTRY_REL = 'registries/design.registry.json';
+
+const UI_CANDIDATES = {
+  nuxt4: ['components/ui'],
+  nextjs: ['src/components/ui'],
+};
+
+const MOLECULE_CANDIDATES = {
+  nuxt4: ['components/molecules', 'components/organisms'],
+  nextjs: ['src/components/molecules', 'src/components/organisms', 'src/components/common'],
+};
+
+/** Vue/Nuxt composables + React hooks / shared logic */
+const COMPOSABLE_CANDIDATES = {
+  nuxt4: ['composables', 'app/composables', 'utils'],
+  nextjs: ['src/hooks', 'src/composables', 'composables', 'src/lib'],
+};
+
+const SHELL_CANDIDATES = {
+  nuxt4: {
+    DataListPage: ['components/organisms/DataListPage.vue', 'components/pages/DataListPage.vue'],
+    DataFormPage: ['components/organisms/DataFormPage.vue'],
+    DataDetailPage: ['components/organisms/DataDetailPage.vue'],
+  },
+  nextjs: {
+    DataListPage: ['src/components/organisms/data-list-page.tsx', 'src/components/templates/data-list-page.tsx'],
+    DataFormPage: ['src/components/organisms/data-form-page.tsx'],
+    DataDetailPage: ['src/components/organisms/data-detail-page.tsx'],
+  },
+};
+
+function folderToPascalCase(kebab) {
+  return String(kebab)
+    .split('-')
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+}
+
+function existsFile(root, rel) {
+  return fs.existsSync(path.join(root, rel));
+}
+
+function loadJson(abs, fallback) {
+  if (!fs.existsSync(abs)) return fallback;
+  try {
+    return JSON.parse(fs.readFileSync(abs, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function deepMergeRegistry(base, patch) {
+  const out = { ...base, ...patch };
+  out.shells = { ...(base.shells ?? {}), ...(patch.shells ?? {}) };
+  out.fieldWidgets = { ...(base.fieldWidgets ?? {}), ...(patch.fieldWidgets ?? {}) };
+  out.components = { ...(base.components ?? {}), ...(patch.components ?? {}) };
+  out.aliasIndex = { ...(base.aliasIndex ?? {}), ...(patch.aliasIndex ?? {}) };
+  out.componentAliases = { ...(base.componentAliases ?? {}), ...(patch.componentAliases ?? {}) };
+  out.composables = { ...(base.composables ?? {}), ...(patch.composables ?? {}) };
+  out.helpers = { ...(base.helpers ?? {}), ...(patch.helpers ?? {}) };
+  return out;
+}
+
+/** @param {string} base filename without ext */
+function composableExportName(base) {
+  if (/^use[A-Z]/.test(base)) return base;
+  if (base.startsWith('use-')) {
+    const rest = base.slice(4).split('-').map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join('');
+    return `use${rest}`;
+  }
+  return null;
+}
+
+function walkDirFiles(dir, exts, max = 500) {
+  const found = [];
+  if (!fs.existsSync(dir)) return found;
+  const stack = [dir];
+  while (stack.length && found.length < max) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const ent of entries) {
+      const full = path.join(current, ent.name);
+      if (ent.isDirectory()) {
+        if (!['node_modules', '.git', 'dist', '.flowgrid'].includes(ent.name)) stack.push(full);
+      } else if (ent.isFile() && exts.some((e) => ent.name.endsWith(e))) {
+        found.push(full);
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * @param {string} projectRoot
+ * @param {string} feAdapter nuxt4 | nextjs
+ * @param {string} packageRoot flowgrid package (for base template)
+ * @param {{ dryRun?: boolean }} opts
+ */
+export function syncFeDesignRegistry(projectRoot, feAdapter, packageRoot, opts = {}) {
+  const adapter = feAdapter === 'nuxt4' ? 'nuxt4' : 'nextjs';
+  const registryDir = path.join(projectRoot, 'registries');
+  const registryPath = path.join(projectRoot, REGISTRY_REL);
+  const baseTemplate = path.join(packageRoot, 'templates/shared/design.registry.base.json');
+  let registry = loadJson(registryPath, loadJson(baseTemplate, { version: 1, shells: {}, fieldWidgets: {}, components: {} }));
+
+  const components = { ...(registry.components ?? {}) };
+  const fieldWidgets = { ...(registry.fieldWidgets ?? {}) };
+  const shells = { ...(registry.shells ?? {}) };
+  const composables = { ...(registry.composables ?? {}) };
+  const helpers = { ...(registry.helpers ?? {}) };
+
+  for (const rel of UI_CANDIDATES[adapter] ?? UI_CANDIDATES.nextjs) {
+    const uiDir = path.join(projectRoot, rel);
+    if (!fs.existsSync(uiDir)) continue;
+    const entries = fs.readdirSync(uiDir, { withFileTypes: true });
+    for (const entry of entries) {
+      let canonical;
+      let relPath;
+      if (adapter === 'nuxt4' && entry.isDirectory()) {
+        canonical = folderToPascalCase(entry.name);
+        relPath = `${rel}/${entry.name}`;
+      } else if (adapter === 'nextjs' && entry.isFile() && /\.(tsx|ts|vue)$/.test(entry.name)) {
+        const base = entry.name.replace(/\.(tsx|ts|vue)$/, '');
+        canonical = folderToPascalCase(base);
+        relPath = `${rel}/${entry.name}`;
+      } else {
+        continue;
+      }
+      components[canonical] = {
+        canonical,
+        category: 'ui',
+        tags: [`#ui: ${canonical}`],
+        portal: { layer: 'ui', path: relPath, status: 'implemented' },
+        source: 'registry:sync',
+      };
+      fieldWidgets[canonical] = fieldWidgets[canonical] ?? {
+        tag: `#widget: ${canonical}`,
+        component: canonical,
+        portal: { ui: canonical, status: 'implemented' },
+        source: 'registry:sync',
+      };
+    }
+  }
+
+  const molRoots = MOLECULE_CANDIDATES[adapter] ?? [];
+  const molFiles = molRoots.flatMap((r) => walkDirFiles(path.join(projectRoot, r), ['.vue', '.tsx', '.ts']));
+  for (const abs of molFiles) {
+    const base = path.basename(abs).replace(/\.(vue|tsx|ts)$/, '');
+    const moName = base.startsWith('Mo') ? base : base.match(/^mo-/) ? `Mo${folderToPascalCase(base.slice(3))}` : null;
+    const key = moName ?? (base.startsWith('Data') ? base : null);
+    if (!key) continue;
+    const rel = path.relative(projectRoot, abs).split(path.sep).join('/');
+    fieldWidgets[key] = {
+      tag: `#widget: ${key}`,
+      component: key,
+      portal: { molecule: key, path: rel, status: 'implemented' },
+      source: 'registry:sync',
+    };
+    if (key.startsWith('Mo')) {
+      components[key] = {
+        canonical: key,
+        category: 'molecule',
+        tags: [`#needs-component: ${key}`],
+        portal: { layer: 'molecule', path: rel, status: 'implemented' },
+        source: 'registry:sync',
+      };
+    }
+  }
+
+  const compRoots = COMPOSABLE_CANDIDATES[adapter] ?? [];
+  const compFiles = compRoots.flatMap((r) =>
+    walkDirFiles(path.join(projectRoot, r), ['.ts', '.js', '.mts']),
+  );
+  for (const abs of compFiles) {
+    const base = path.basename(abs).replace(/\.(ts|js|mts)$/, '');
+    if (base === 'index' || base.endsWith('.test') || base.endsWith('.spec')) continue;
+    const rel = path.relative(projectRoot, abs).split(path.sep).join('/');
+    const useName = composableExportName(base);
+    if (useName) {
+      composables[useName] = {
+        export: useName,
+        tags: [`#composable: ${useName}`],
+        path: rel,
+        status: 'implemented',
+        source: 'registry:sync',
+      };
+      continue;
+    }
+    const helperKey = folderToPascalCase(base);
+    if (rel.includes('/utils/') || rel.startsWith('utils/') || rel.includes('/lib/')) {
+      helpers[helperKey] = {
+        symbol: helperKey,
+        tags: [`#helper: ${helperKey}`],
+        path: rel,
+        status: 'implemented',
+        source: 'registry:sync',
+      };
+    }
+  }
+
+  for (const [shellName, candidates] of Object.entries(SHELL_CANDIDATES[adapter] ?? {})) {
+    const hit = candidates.find((c) => existsFile(projectRoot, c));
+    const prev = shells[shellName] ?? registry.shells?.[shellName] ?? { tag: `#shell: ${shellName}` };
+    shells[shellName] = {
+      ...prev,
+      tag: prev.tag ?? `#shell: ${shellName}`,
+      portal: {
+        ...(prev.portal ?? {}),
+        status: hit ? 'implemented' : prev.portal?.status ?? 'planned',
+        path: hit ?? prev.portal?.path,
+      },
+    };
+  }
+
+  const componentsJson = path.join(projectRoot, 'components.json');
+  if (fs.existsSync(componentsJson)) {
+    const cj = loadJson(componentsJson, {});
+    const uiAlias = cj?.aliases?.ui ?? cj?.aliases?.components;
+    if (typeof uiAlias === 'string') {
+      registry._shadcnUiAlias = uiAlias;
+    }
+  }
+
+  const merged = deepMergeRegistry(registry, {
+    components,
+    fieldWidgets,
+    shells,
+    composables,
+    helpers,
+    scannedAt: new Date().toISOString(),
+    scannedAdapter: adapter,
+  });
+
+  const report = {
+    registryPath: REGISTRY_REL,
+    uiComponents: Object.keys(components).length,
+    composables: Object.keys(merged.composables ?? {}).length,
+    helpers: Object.keys(merged.helpers ?? {}).length,
+    fieldWidgets: Object.keys(merged.fieldWidgets ?? {}).length,
+    shellsImplemented: Object.values(merged.shells ?? {}).filter((s) => s.portal?.status === 'implemented').length,
+  };
+
+  if (opts.dryRun) {
+    return { ok: true, dryRun: true, report, registry: merged };
+  }
+
+  if (!fs.existsSync(registryDir)) fs.mkdirSync(registryDir, { recursive: true });
+  fs.writeFileSync(registryPath, JSON.stringify(merged, null, 2) + '\n');
+  return { ok: true, report, registryPath };
+}

package/engines/registry-sync/run-registry-sync.mjs

@@ -0,0 +1,107 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import pc from 'picocolors';
+import { syncFeDesignRegistry } from './fe-design-sync.mjs';
+import { syncBeCapabilitiesRegistry } from './be-capabilities-sync.mjs';
+
+function packageRootFromMeta(metaUrl) {
+  return path.resolve(path.dirname(metaUrl), '../..');
+}
+
+async function rebuildArtifactGraphIndex(projectRoot) {
+  try {
+    const { loadEffectiveRepoConfig } = await import('../../dist/graph/config/load-config.js');
+    const { IndexStore } = await import('../../dist/graph/db/index-store.js');
+    const { loadRegistries, indexRegistries } = await import('../../dist/graph/registry/load-registries.js');
+    const { indexLexicons } = await import('../../dist/graph/lexicon/load-lexicon.js');
+    const cfg = loadEffectiveRepoConfig(projectRoot);
+    const store = new IndexStore(projectRoot);
+    store.transaction(() => {
+      const loaded = loadRegistries(projectRoot, cfg);
+      indexRegistries(store, loaded, projectRoot, cfg);
+      indexLexicons(store, projectRoot, cfg);
+    });
+    store.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string[]} argv
+ * @param {{ packageRoot?: string, projectRoot?: string, config?: object }} ctx
+ */
+export async function runRegistrySync(argv = [], ctx = {}) {
+  const projectRoot = ctx.projectRoot ?? process.cwd();
+  const packageRoot = ctx.packageRoot ?? packageRootFromMeta(import.meta.url);
+  const dryRun = argv.includes('--dry-run');
+  const feOnly = argv.includes('--fe');
+  const beOnly = argv.includes('--be');
+
+  const configPath = path.join(projectRoot, '.flowgrid/config.json');
+  let config = ctx.config ?? {};
+  if (!ctx.config && fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch {
+      config = {};
+    }
+  }
+
+  const feAdapter = config.frontend?.adapter;
+  const beAdapter = config.backend?.adapter;
+  const type = config.type ?? '';
+  const baseProfile = config.baseProfile ?? 'standard';
+
+  const runFe =
+    !beOnly &&
+    feAdapter &&
+    ['nuxt4', 'nextjs'].includes(feAdapter) &&
+    (feOnly || ['Frontend', 'Fullstack'].includes(type) || argv.includes('--fe'));
+  const runBe =
+    !feOnly &&
+    beAdapter &&
+    (beOnly || ['Backend', 'Fullstack'].includes(type) || argv.includes('--be'));
+
+  if (baseProfile === 'custom' && !argv.includes('--force')) {
+    console.log(
+      pc.yellow(
+        '[registry:sync] baseProfile=custom — skip FE scan (use build-template-code). Pass --force to scan anyway.',
+      ),
+    );
+    if (!runBe) return { code: 0 };
+  }
+
+  console.log(pc.cyan('\n=== flowgrid registry:sync ==='));
+  console.log(`  root: ${projectRoot}`);
+  if (dryRun) console.log(pc.magenta('  mode: dry-run'));
+
+  if (runFe) {
+    const fe = syncFeDesignRegistry(projectRoot, feAdapter, packageRoot, { dryRun });
+    console.log(pc.green('✔ FE design registry'));
+    console.log(
+      `    ${fe.report.registryPath}: ui=${fe.report.uiComponents} composables=${fe.report.composables} helpers=${fe.report.helpers} widgets=${fe.report.fieldWidgets} shells=${fe.report.shellsImplemented}`,
+    );
+  } else if (!beOnly) {
+    console.log(pc.gray('  (skip FE — no nuxt4/nextjs frontend in config)'));
+  }
+
+  if (runBe) {
+    const be = syncBeCapabilitiesRegistry(projectRoot, beAdapter, packageRoot, { dryRun });
+    console.log(pc.green('✔ BE capabilities registry'));
+    console.log(
+      `    ${be.report.registryPath}: entries=${be.report.capabilityKeys} middleware=${be.report.middleware}`,
+    );
+  } else if (!feOnly) {
+    console.log(pc.gray('  (skip BE — no backend adapter in config)'));
+  }
+
+  if (!dryRun && (runFe || runBe)) {
+    const ok = await rebuildArtifactGraphIndex(projectRoot);
+    if (ok) console.log(pc.gray('  + ArtifactGraph index rebuilt (.flowgrid/index.db)'));
+  }
+
+  console.log('');
+  return { code: 0 };
+}

package/engines/shared/e2e-output-layout.mjs

@@ -0,0 +1,68 @@
+import path from 'node:path';
+
+import {
+  API_E2E_ROOT_DIR_PARTS,
+  DEFAULT_E2E_ROOT_BACKEND_REL,
+  DEFAULT_E2E_ROOT_REL,
+  E2E_ROOT_DIR_PARTS,
+} from './flowgrid-e2e-root.mjs';
+
+/**
+ * Relative codegen + preflight trees from project root, given resolved automation root.
+ * @param {string} projectRoot
+ * @param {string | null | undefined} e2eRootAbs
+ * @param {{ projectType?: string }} [opts]
+ */
+export function codegenOutputLayout(projectRoot, e2eRootAbs, opts = {}) {
+  const resolvedProject = path.resolve(projectRoot);
+  let e2eAbs = e2eRootAbs ? path.resolve(e2eRootAbs) : null;
+  if (!e2eAbs) {
+    const rel =
+      opts.projectType === 'Backend' ? DEFAULT_E2E_ROOT_BACKEND_REL : DEFAULT_E2E_ROOT_REL;
+    e2eAbs = path.join(resolvedProject, rel);
+  }
+
+  const uiPrefix = path.relative(resolvedProject, e2eAbs).split(path.sep).join('/');
+  const defaultApi = path.join(...API_E2E_ROOT_DIR_PARTS);
+  let apiPrefix = defaultApi;
+
+  const uiNorm = uiPrefix.replace(/\\/g, '/');
+  if (uiNorm === 'tests') {
+    apiPrefix = defaultApi;
+  } else if (uiNorm === 'tests/e2e' || uiNorm.endsWith('/e2e')) {
+    const parent = path.dirname(uiNorm);
+    apiPrefix = parent === '.' ? 'api-e2e' : `${parent}/api-e2e`;
+  }
+
+  const allowedRelRoots = [
+    path.join(...E2E_ROOT_DIR_PARTS),
+    path.join(...API_E2E_ROOT_DIR_PARTS),
+    uiPrefix,
+    apiPrefix,
+  ]
+    .map((p) => p.replace(/\\/g, '/'))
+    .filter((p, i, arr) => p && arr.indexOf(p) === i);
+
+  return {
+    projectRoot: resolvedProject,
+    e2eRootAbs: e2eAbs,
+    uiPrefix,
+    apiPrefix,
+    allowedRelRoots,
+  };
+}
+
+/**
+ * Directories to scan for Playwright specs (UI + api-e2e).
+ * @param {string} projectRoot
+ * @param {string | null | undefined} e2eRootAbs
+ */
+export function playwrightScanRoots(projectRoot, e2eRootAbs) {
+  const layout = codegenOutputLayout(projectRoot, e2eRootAbs);
+  const roots = [layout.e2eRootAbs];
+  const apiAbs = path.join(layout.projectRoot, layout.apiPrefix);
+  if (apiAbs !== layout.e2eRootAbs) {
+    roots.push(apiAbs);
+  }
+  return roots;
+}

package/engines/shared/flowgrid-e2e-root.mjs

@@ -0,0 +1,19 @@
+/**
+ * Playwright automation roots (relative to code repo).
+ * testcase:gen (UI) → tests/e2e; testcase:gen:api → tests/api-e2e.
+ * audit e2e --e2e-root scans recursively for *.spec.ts / *.api.spec.ts.
+ * Distinct from tests-docs hub (YAML plan) and playwright.config (often repo root).
+ */
+export const E2E_ROOT_DIR_PARTS = ['tests', 'e2e'];
+export const API_E2E_ROOT_DIR_PARTS = ['tests', 'api-e2e'];
+
+export const DEFAULT_E2E_ROOT_REL = 'tests/e2e';
+/** Backend / API-hook lane: scan parent so api-e2e + optional UI specs both count. */
+export const DEFAULT_E2E_ROOT_BACKEND_REL = 'tests';
+
+/**
+ * @param {'Frontend' | 'Backend' | 'Fullstack' | string} projectType
+ */
+export function defaultE2eRootRel(projectType) {
+  return projectType === 'Backend' ? DEFAULT_E2E_ROOT_BACKEND_REL : DEFAULT_E2E_ROOT_REL;
+}