@team-codeme/crud-forge 0.0.0-stage → 1.0.0

package/src/templates/fuse-packs/access-control-tools/build-rename-map.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Build assets/screen-id-rename-map.json from output/sync-report.json (tsUpdated).
+ * Usage (repo root):
+ *   node src/app/domains/admin/modules/apps/shared/access-control-tools/build-rename-map.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const TOOLS_DIR = __dirname;
+const REPORT = path.join(TOOLS_DIR, 'output', 'sync-report.json');
+const OUT_TOOLS = path.join(TOOLS_DIR, 'output', 'screen-id-rename-map.json');
+const OUT_ASSETS = path.join(TOOLS_DIR, '../../../../../../../assets/screen-id-rename-map.json');
+
+const REGION_BASELINE = {
+  region: 'regional-office',
+  'region-list': 'regional-office-list',
+  'region-form': 'regional-office-form',
+  'region-filter': 'regional-office-filter',
+  'region-detail': 'regional-office-detail',
+  'region-actions': 'regional-office-actions',
+  'region-card': 'regional-office-card',
+  'region-form-page': 'regional-office-form-page',
+  'region-side-detail': 'regional-office-side-detail',
+  'region-team-drawer': 'regional-office-team-drawer',
+  'region-org-tree-drawer': 'regional-office-org-tree-drawer',
+};
+
+function main() {
+  const map = { ...REGION_BASELINE };
+  if (fs.existsSync(REPORT)) {
+    const report = JSON.parse(fs.readFileSync(REPORT, 'utf8'));
+    for (const row of report.tsUpdated || report.tsWouldUpdate || []) {
+      for (const change of row.changes || []) {
+        const m = String(change).match(/SCREEN\s+'([^']+)'\s*→\s*'([^']+)'/);
+        if (m && m[1] !== m[2]) {
+          map[m[1]] = m[2];
+        }
+      }
+    }
+  }
+
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    source: 'sync-report.tsUpdated + regional-office baseline',
+    renames: Object.fromEntries(Object.entries(map).sort(([a], [b]) => a.localeCompare(b))),
+  };
+
+  const json = JSON.stringify(payload, null, 2);
+  fs.mkdirSync(path.dirname(OUT_TOOLS), { recursive: true });
+  fs.writeFileSync(OUT_TOOLS, json, 'utf8');
+  const assetsDir = path.dirname(OUT_ASSETS);
+  if (fs.existsSync(assetsDir)) {
+    fs.writeFileSync(OUT_ASSETS, json, 'utf8');
+  }
+
+  console.log(`Wrote ${Object.keys(payload.renames).length} renames`);
+  console.log(`  ${path.relative(process.cwd(), OUT_TOOLS)}`);
+  if (fs.existsSync(assetsDir)) {
+    console.log(`  ${path.relative(process.cwd(), OUT_ASSETS)}`);
+  }
+}
+
+main();

package/src/templates/fuse-packs/access-control-tools/inject-qa-ids.js

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * @deprecated Prefer access-control-sync.js
+ * Thin wrapper kept for existing docs / habits.
+ */
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const syncScript = path.join(__dirname, 'access-control-sync.js');
+const result = spawnSync(process.execPath, [syncScript, '--write', '--qa-only'], {
+  stdio: 'inherit',
+});
+process.exit(result.status ?? 1);

package/src/templates/fuse-packs/access-control-tools/lib/hierarchy-scanner.js

@@ -0,0 +1,628 @@
+'use strict';
+
+/**
+ * Discover page → embedded-screen hierarchy from Angular routes + templates.
+ * Uses TypeScript AST component index for selectors / SCREEN / multi-component files.
+ * Does not invent relationships for dynamic/unknown selectors — those are reported.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const {
+  buildComponentCatalog,
+  extractRouteComponentHits,
+  classifyRootCause,
+  screenOwnerScore,
+} = require('./ts-component-index');
+
+const APP_TAG_RE = /<(app-[a-z0-9-]+)\b/gi;
+const DYNAMIC_OUTLET_RE = /ngComponentOutlet|cdkPortalOutlet|ndcDynamic/i;
+const STATIC_OUTLET_CLASS_RE =
+  /\[ngComponentOutlet\]\s*=\s*["'](\w+)["']|ngComponentOutlet\s*=\s*["'](\w+)["']/gi;
+const MAX_TEMPLATE_DEPTH = 5;
+
+const NOISE_SELECTOR_RE =
+  /(toggle|chip|skeleton|spinner|overlay|icon|badge|tooltip|menu|divider|avatar|chart|uploader|viewer|breadcrumb|paginator|loading)/i;
+
+function readSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function walkFiles(dir, predicate, out = []) {
+  if (!fs.existsSync(dir)) {
+    return out;
+  }
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkFiles(full, predicate, out);
+    } else if (predicate(full)) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function titleFromScreenName(screenName, screenId) {
+  const cleaned = String(screenName || '')
+    .replace(/^I-/i, '')
+    .trim();
+  if (cleaned) {
+    return cleaned;
+  }
+  return String(screenId || '')
+    .split('-')
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+}
+
+function domainFromPath(tsFile, appsRoot) {
+  const rel = path.relative(appsRoot, tsFile).replace(/\\/g, '/');
+  const parts = rel.split('/');
+  if (parts[0] === 'pages' && parts[1]) {
+    return parts[1]
+      .split('-')
+      .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+      .join(' ');
+  }
+  if (parts[0] === 'micro-functions' && parts[1]) {
+    return parts[1]
+      .replace(/Module$/i, '')
+      .replace(/([a-z])([A-Z])/g, '$1 $2')
+      .replace(/-/g, ' ')
+      .replace(/\b\w/g, (c) => c.toUpperCase());
+  }
+  if (parts[0] === 'shared') {
+    return 'Shared';
+  }
+  return 'Application';
+}
+
+function inferSourceType(tsFile, appsRoot) {
+  const rel = path.relative(appsRoot, tsFile).replace(/\\/g, '/');
+  if (rel.startsWith('pages/')) {
+    return 'pages';
+  }
+  if (rel.startsWith('shared/')) {
+    return 'shared';
+  }
+  return 'micro-functions';
+}
+
+function isLikelyHostScreen(screenId, sourceType, isRouted) {
+  if (isRouted) {
+    return true;
+  }
+  if (sourceType === 'pages') {
+    return true;
+  }
+  const id = String(screenId || '').toLowerCase();
+  return /-(list|page)$/.test(id) || id.endsWith('-management-list');
+}
+
+/**
+ * Merge sync workItems (Keycloak-aligned names/templates) into the AST catalog.
+ * Never move a SCREEN onto a sibling @Component in a multi-component file.
+ */
+function mergeWorkItemsIntoCatalog(catalog, workItems, appsRoot) {
+  for (const item of workItems || []) {
+    const siblings = catalog.components.filter((c) => c.tsFile === item.tsFile);
+    let meta =
+      siblings.find((c) => c.className === item.className) ||
+      siblings.find((c) => item.screenId && c.screenId === item.screenId) ||
+      siblings.find((c) => c.screenId) ||
+      null;
+
+    if (!meta) {
+      meta = {
+        tsFile: item.tsFile,
+        className: item.className,
+        selector: '',
+        screenId: item.screenId || null,
+        screenName: item.screenName,
+        templateContent: item.templateContent || '',
+        htmlPath: item.htmlPath || '',
+        sourceType: item.sourceType || inferSourceType(item.tsFile, appsRoot),
+        importNames: [],
+        standalone: null,
+        sourceText: item.fileContent || '',
+      };
+      catalog.components.push(meta);
+    } else {
+      // Only fill missing screenId when AST found none on any sibling (avoid dialog theft).
+      const anyAstScreen = siblings.some((c) => c.screenId);
+      if (!meta.screenId && item.screenId && !anyAstScreen && meta.className === item.className) {
+        meta.screenId = item.screenId;
+      }
+      if (item.screenName && (meta.screenId === item.screenId || !meta.screenName)) {
+        meta.screenName = item.screenName;
+      }
+      if (!meta.templateContent && item.templateContent) {
+        meta.templateContent = item.templateContent;
+        meta.htmlPath = item.htmlPath || meta.htmlPath;
+      }
+      meta.sourceType =
+        item.sourceType || meta.sourceType || inferSourceType(meta.tsFile, appsRoot);
+    }
+
+    // Prefer workItem template for the SCREEN-owning sibling when sync already loaded it.
+    if (item.templateContent && item.screenId) {
+      const owner = siblings.find((c) => c.screenId === item.screenId) || meta;
+      if (owner && !owner.templateContent) {
+        owner.templateContent = item.templateContent;
+        owner.htmlPath = item.htmlPath || owner.htmlPath;
+      }
+      if (owner && item.screenName) {
+        owner.screenName = item.screenName;
+      }
+    }
+  }
+
+  catalog.bySelector.clear();
+  catalog.byClassName.clear();
+  catalog.byScreenId.clear();
+  for (const meta of catalog.components) {
+    meta.sourceType = meta.sourceType || inferSourceType(meta.tsFile, appsRoot);
+    if (meta.selector) {
+      const existing = catalog.bySelector.get(meta.selector);
+      if (!existing || (!existing.screenId && meta.screenId)) {
+        catalog.bySelector.set(meta.selector, meta);
+      }
+    }
+    if (meta.className) {
+      catalog.byClassName.set(meta.className, meta);
+    }
+    if (meta.screenId) {
+      const prev = catalog.byScreenId.get(meta.screenId);
+      if (!prev || screenOwnerScore(meta) > screenOwnerScore(prev)) {
+        catalog.byScreenId.set(meta.screenId, meta);
+      }
+    }
+  }
+}
+
+/**
+ * @param {object} opts
+ * @param {Array<{tsFile:string,fileContent:string,className:string,templateContent:string,htmlPath:string,screenId:string,screenName:string,sourceType?:string}>} opts.workItems
+ * @param {string} opts.appsRoot - .../modules/apps
+ * @param {string} [opts.adminRoutesFile] - admin/routes.ts for URL prefixes
+ */
+function buildScreenNavigationHierarchy(opts) {
+  const { workItems, appsRoot, adminRoutesFile } = opts;
+  const unresolved = [];
+  const resolvedWithoutScreen = [];
+  const warnings = [];
+  const rootCauseCounts = Object.create(null);
+
+  const sharedRoot = path.join(appsRoot, 'shared');
+  const pagesRoot = path.join(appsRoot, 'pages');
+  const microRoot = path.join(appsRoot, 'micro-functions');
+
+  const catalog = buildComponentCatalog([microRoot, pagesRoot, sharedRoot]);
+  mergeWorkItemsIntoCatalog(catalog, workItems, appsRoot);
+
+  const bySelector = catalog.bySelector;
+  const byClassName = catalog.byClassName;
+  const byScreenId = catalog.byScreenId;
+
+  // Route class → path segments
+  const routeHits = new Map();
+  const routeFiles = walkFiles(
+    appsRoot,
+    (f) => f.endsWith('.routes.ts') || f.endsWith('/routes.ts') || f.endsWith('\\routes.ts')
+  );
+  if (adminRoutesFile && fs.existsSync(adminRoutesFile)) {
+    routeFiles.push(adminRoutesFile);
+  }
+
+  const urlPrefixByRouteFile = buildUrlPrefixIndex(adminRoutesFile, appsRoot);
+
+  for (const routesFile of routeFiles) {
+    const text = readSafe(routesFile);
+    if (!text) {
+      continue;
+    }
+    const hits = extractRouteComponentHits(routesFile, text);
+    for (const hit of hits) {
+      if (!hit.className) {
+        continue;
+      }
+      const list = routeHits.get(hit.className) || [];
+      list.push({ path: hit.path, routesFile: hit.routesFile, kind: hit.kind });
+      routeHits.set(hit.className, list);
+    }
+  }
+
+  const routedClassNames = new Set(routeHits.keys());
+
+  /** parentScreenId -> Map(childScreenId -> embedRef) */
+  const embedsByHost = new Map();
+
+  function addEmbed(hostScreenId, childMeta, isPrimary) {
+    if (!hostScreenId || !childMeta?.screenId || hostScreenId === childMeta.screenId) {
+      return;
+    }
+    let map = embedsByHost.get(hostScreenId);
+    if (!map) {
+      map = new Map();
+      embedsByHost.set(hostScreenId, map);
+    }
+    if (!map.has(childMeta.screenId)) {
+      map.set(childMeta.screenId, {
+        screenId: childMeta.screenId,
+        title: titleFromScreenName(childMeta.screenName, childMeta.screenId),
+        isPrimary: Boolean(isPrimary),
+      });
+    } else if (isPrimary) {
+      map.get(childMeta.screenId).isPrimary = true;
+    }
+  }
+
+  function bumpCause(code) {
+    rootCauseCounts[code] = (rootCauseCounts[code] || 0) + 1;
+  }
+
+  function reportUnresolved(hostScreenId, selector, reason, file, extra = {}) {
+    const entry = {
+      hostScreenId: hostScreenId || null,
+      selector,
+      reason,
+      file: file ? path.relative(process.cwd(), file) : null,
+      parentComponent: extra.parentComponent || null,
+      ...extra,
+    };
+    unresolved.push(entry);
+    bumpCause(extra.rootCause || 'unresolved');
+  }
+
+  function reportResolvedWithoutScreen(hostMeta, selector, childMeta) {
+    const cause = classifyRootCause({
+      selector,
+      childMeta,
+      hostFile: hostMeta.tsFile,
+    });
+    bumpCause(cause.code);
+    resolvedWithoutScreen.push({
+      hostScreenId: hostMeta.screenId || null,
+      selector,
+      parentComponent: hostMeta.className || null,
+      childComponent: childMeta.className || null,
+      file: childMeta.tsFile ? path.relative(process.cwd(), childMeta.tsFile) : null,
+      parentFile: hostMeta.htmlPath || hostMeta.tsFile
+        ? path.relative(process.cwd(), hostMeta.htmlPath || hostMeta.tsFile)
+        : null,
+      reason: cause.detail,
+      rootCause: cause.code,
+    });
+  }
+
+  function isPrimaryChild(screenId) {
+    const id = String(screenId || '');
+    return (
+      /-(form|detail)$/.test(id) ||
+      id.includes('details-form') ||
+      id.endsWith('-form')
+    );
+  }
+
+  /**
+   * Recursively walk template tags. SCREEN children become embeds of the host.
+   * Children without SCREEN are recorded as resolvedWithoutScreen and still walked
+   * so nested SCREEN widgets surface under the same host.
+   */
+  function walkTemplate(hostMeta, html, depth, visitedSelectors, sourceFile) {
+    if (!html || depth > MAX_TEMPLATE_DEPTH) {
+      return;
+    }
+
+    if (DYNAMIC_OUTLET_RE.test(html)) {
+      // Attempt static ngComponentOutlet="ClassName" resolution first.
+      let staticResolved = false;
+      STATIC_OUTLET_CLASS_RE.lastIndex = 0;
+      let outletMatch;
+      while ((outletMatch = STATIC_OUTLET_CLASS_RE.exec(html)) !== null) {
+        const className = outletMatch[1] || outletMatch[2];
+        const child = byClassName.get(className);
+        if (child?.screenId && child.screenId !== hostMeta.screenId) {
+          addEmbed(hostMeta.screenId, child, isPrimaryChild(child.screenId));
+          staticResolved = true;
+          if (child.templateContent) {
+            walkTemplate(
+              hostMeta,
+              child.templateContent,
+              depth + 1,
+              visitedSelectors,
+              child.htmlPath || child.tsFile
+            );
+          }
+        } else if (child && !child.screenId) {
+          reportResolvedWithoutScreen(hostMeta, child.selector || className, child);
+          staticResolved = true;
+        }
+      }
+      if (!staticResolved) {
+        reportUnresolved(
+          hostMeta.screenId,
+          '(dynamic-outlet)',
+          'Template uses a dynamic component outlet that could not be resolved statically',
+          sourceFile || hostMeta.htmlPath || hostMeta.tsFile,
+          {
+            parentComponent: hostMeta.className,
+            rootCause: 'dynamic_outlet_unresolved',
+          }
+        );
+      }
+    }
+
+    const seenTags = new Set();
+    APP_TAG_RE.lastIndex = 0;
+    let tagMatch;
+    while ((tagMatch = APP_TAG_RE.exec(html)) !== null) {
+      const tag = tagMatch[1].toLowerCase();
+      if (seenTags.has(tag)) {
+        continue;
+      }
+      seenTags.add(tag);
+
+      const visitKey = `${hostMeta.screenId}::${tag}`;
+      if (visitedSelectors.has(visitKey)) {
+        continue;
+      }
+      visitedSelectors.add(visitKey);
+
+      const child = bySelector.get(tag);
+      if (!child) {
+        if (!NOISE_SELECTOR_RE.test(tag)) {
+          const cause = classifyRootCause({ selector: tag, childMeta: null });
+          reportUnresolved(
+            hostMeta.screenId,
+            tag,
+            cause.detail,
+            sourceFile || hostMeta.htmlPath || hostMeta.tsFile,
+            {
+              parentComponent: hostMeta.className,
+              rootCause: cause.code,
+            }
+          );
+        }
+        continue;
+      }
+
+      if (child.screenId && child.screenId !== hostMeta.screenId) {
+        addEmbed(hostMeta.screenId, child, isPrimaryChild(child.screenId));
+        if (child.templateContent) {
+          walkTemplate(
+            hostMeta,
+            child.templateContent,
+            depth + 1,
+            visitedSelectors,
+            child.htmlPath || child.tsFile
+          );
+        }
+        continue;
+      }
+
+      if (!child.screenId) {
+        reportResolvedWithoutScreen(hostMeta, tag, child);
+        if (child.templateContent) {
+          walkTemplate(
+            hostMeta,
+            child.templateContent,
+            depth + 1,
+            visitedSelectors,
+            child.htmlPath || child.tsFile
+          );
+        }
+      }
+    }
+  }
+
+  for (const meta of byScreenId.values()) {
+    const html = meta.templateContent || '';
+    if (!html) {
+      continue;
+    }
+    walkTemplate(meta, html, 0, new Set(), meta.htmlPath || meta.tsFile);
+  }
+
+  // Build page entries for hosts that are routed/list/page AND have embeds
+  const pages = [];
+  const pageByHost = new Map();
+
+  for (const [hostScreenId, embedMap] of embedsByHost.entries()) {
+    const hostMeta = byScreenId.get(hostScreenId);
+    if (!hostMeta) {
+      continue;
+    }
+    const isRouted = routedClassNames.has(hostMeta.className);
+    if (!isLikelyHostScreen(hostScreenId, hostMeta.sourceType, isRouted)) {
+      continue;
+    }
+    if (embedMap.size === 0) {
+      continue;
+    }
+
+    const route = resolveRouteForClass(hostMeta.className, routeHits, urlPrefixByRouteFile);
+    const embeddedScreens = [...embedMap.values()].sort((a, b) =>
+      a.screenId.localeCompare(b.screenId)
+    );
+
+    const entry = {
+      domain: domainFromPath(hostMeta.tsFile, appsRoot),
+      navTitle: titleFromScreenName(hostMeta.screenName, hostScreenId),
+      route,
+      hostScreenId,
+      embeddedScreens,
+    };
+
+    if (pageByHost.has(hostScreenId)) {
+      const existing = pageByHost.get(hostScreenId);
+      const merged = new Map(existing.embeddedScreens.map((e) => [e.screenId, e]));
+      embeddedScreens.forEach((e) => {
+        if (!merged.has(e.screenId)) {
+          merged.set(e.screenId, e);
+        } else if (e.isPrimary) {
+          merged.get(e.screenId).isPrimary = true;
+        }
+      });
+      existing.embeddedScreens = [...merged.values()].sort((a, b) =>
+        a.screenId.localeCompare(b.screenId)
+      );
+      if (!existing.route && route) {
+        existing.route = route;
+      }
+    } else {
+      pageByHost.set(hostScreenId, entry);
+      pages.push(entry);
+    }
+  }
+
+  pages.sort((a, b) => {
+    const d = a.domain.localeCompare(b.domain);
+    if (d !== 0) {
+      return d;
+    }
+    return a.navTitle.localeCompare(b.navTitle);
+  });
+
+  const unresolvedUnique = dedupeByKey(unresolved, (item) =>
+    `${item.hostScreenId || ''}::${item.selector}::${item.reason}`
+  );
+  const resolvedWithoutScreenUnique = dedupeByKey(
+    resolvedWithoutScreen,
+    (item) => `${item.hostScreenId || ''}::${item.selector}::${item.childComponent || ''}`
+  );
+
+  return {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    pages,
+    unresolved: unresolvedUnique,
+    resolvedWithoutScreen: resolvedWithoutScreenUnique,
+    classification: {
+      rootCauseCounts,
+      notes: [
+        'Embed edges require a child SCREEN / DEFAULT_SCREEN — never invented.',
+        'Reusable components may appear under multiple host routes without merging grants.',
+        'Sensitive actions (Delete/Approve/Reject/Finalize) remain explicit in the matrix UI.',
+      ],
+    },
+    stats: {
+      componentIndexSize: byScreenId.size,
+      selectorIndexSize: bySelector.size,
+      astComponentCount: catalog.components.length,
+      routedComponents: routedClassNames.size,
+      pageCount: pages.length,
+      embedEdgeCount: [...embedsByHost.values()].reduce((n, m) => n + m.size, 0),
+      unresolvedCount: unresolvedUnique.length,
+      resolvedWithoutScreenCount: resolvedWithoutScreenUnique.length,
+    },
+    warnings,
+  };
+}
+
+function dedupeByKey(items, keyFn) {
+  const out = [];
+  const keys = new Set();
+  for (const item of items) {
+    const key = keyFn(item);
+    if (keys.has(key)) {
+      continue;
+    }
+    keys.add(key);
+    out.push(item);
+  }
+  return out;
+}
+
+function buildUrlPrefixIndex(adminRoutesFile, appsRoot) {
+  /** @type {Map<string, string>} routesFileAbs -> /admin/... prefix */
+  const map = new Map();
+  if (!adminRoutesFile || !fs.existsSync(adminRoutesFile)) {
+    return map;
+  }
+  const text = readSafe(adminRoutesFile);
+  const blockRe =
+    /path\s*:\s*['"]([^'"]+)['"]\s*,\s*loadChildren\s*:\s*\(\)\s*=>\s*import\(\s*['"]([^'"]+)['"]\s*\)/g;
+  let match;
+  while ((match = blockRe.exec(text)) !== null) {
+    const urlSeg = match[1];
+    const importPath = match[2];
+    const candidates = [
+      path.resolve(path.dirname(adminRoutesFile), `${importPath}.ts`),
+      path.resolve(path.dirname(adminRoutesFile), importPath, 'index.ts'),
+    ];
+    if (importPath.includes('modules/apps')) {
+      const idx = importPath.indexOf('modules/apps');
+      candidates.push(
+        path.join(
+          appsRoot,
+          '..',
+          '..',
+          '..',
+          importPath.slice(idx).replace(/^modules\/apps\/?/, '') + '.ts'
+        )
+      );
+    }
+    for (const candidate of candidates) {
+      const normalized = candidate.replace(/\\/g, '/');
+      map.set(normalized, `/admin/${urlSeg}`);
+    }
+    map.set(`import:${importPath}`, `/admin/${urlSeg}`);
+  }
+  return map;
+}
+
+function resolveRouteForClass(className, routeHits, urlPrefixByRouteFile) {
+  const hits = routeHits.get(className) || [];
+  if (hits.length === 0) {
+    return '';
+  }
+  const hit = hits[0];
+  const routesFile = hit.routesFile.replace(/\\/g, '/');
+  let prefix = '';
+  for (const [key, value] of urlPrefixByRouteFile.entries()) {
+    if (
+      key.startsWith('import:') &&
+      routesFile.includes(key.slice('import:'.length).split('/').slice(-2).join('/'))
+    ) {
+      prefix = value;
+      break;
+    }
+    if (routesFile === key.replace(/\\/g, '/')) {
+      prefix = value;
+      break;
+    }
+  }
+  if (!prefix) {
+    for (const [key, value] of urlPrefixByRouteFile.entries()) {
+      if (!key.startsWith('import:')) {
+        continue;
+      }
+      const importPath = key.slice('import:'.length);
+      const base = importPath.split('/').filter(Boolean).slice(-2).join('/');
+      if (base && routesFile.includes(base)) {
+        prefix = value;
+        break;
+      }
+    }
+  }
+
+  const seg = hit.path || '';
+  if (!prefix) {
+    return seg ? `/${seg}` : '';
+  }
+  if (!seg || seg === '') {
+    return prefix;
+  }
+  return `${prefix}/${seg}`.replace(/\/+/g, '/');
+}
+
+module.exports = {
+  buildScreenNavigationHierarchy,
+};