@cleya/contributor-react-navigation 0.0.0-stage → 1.0.0-next.0

package/dist/react-navigation.index.js

@@ -0,0 +1,1522 @@
+// @bun
+// src/react-navigation.contributor.ts
+import { regionNavigation } from "@cleya/region-navigation";
+
+// src/blank.ts
+var stripNoise = (src) => {
+  let out = "";
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === "/" && src[i + 1] === "/") {
+      const j = src.indexOf(`
+`, i);
+      const end = j < 0 ? src.length : j;
+      out += " ".repeat(end - i);
+      i = end;
+    } else if (c === "/" && src[i + 1] === "*") {
+      const j = src.indexOf("*/", i + 2);
+      const end = j < 0 ? src.length : j + 2;
+      out += " ".repeat(end - i);
+      i = end;
+    } else if (c === '"' || c === "'" || c === "`") {
+      let j = i + 1;
+      while (j < src.length && src[j] !== c)
+        j += src[j] === "\\" ? 2 : 1;
+      const end = Math.min(j + 1, src.length);
+      out += " ".repeat(end - i);
+      i = end;
+    } else {
+      out += c;
+      i += 1;
+    }
+  }
+  return out;
+};
+var lineAt = (src, index) => src.slice(0, index).split(`
+`).length - 1;
+var depthAt = (blanked, index) => {
+  let depth = 0;
+  for (let i = 0;i < index; i++) {
+    const ch = blanked[i];
+    if (ch === "{")
+      depth += 1;
+    else if (ch === "}")
+      depth -= 1;
+  }
+  return depth;
+};
+var topLevelAttr = (attrsSrc, attrsBlanked, attr) => {
+  for (const m of attrsBlanked.matchAll(new RegExp(`\\b${attr}\\s*=`, "g"))) {
+    if (depthAt(attrsBlanked, m.index) !== 0)
+      continue;
+    let at = m.index + m[0].length;
+    while (at < attrsSrc.length && /\s/.test(attrsSrc[at]))
+      at += 1;
+    const quote = attrsSrc[at];
+    if (quote === '"' || quote === "'") {
+      const end = attrsSrc.indexOf(quote, at + 1);
+      if (end > 0)
+        return { literal: attrsSrc.slice(at + 1, end), expr: null, at: at + 1 };
+      continue;
+    }
+    if (attrsBlanked[at] !== "{")
+      continue;
+    let depth = 0;
+    for (let i = at;i < attrsBlanked.length; i++) {
+      const ch = attrsBlanked[i];
+      if (ch === "{")
+        depth += 1;
+      else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0)
+          return { literal: null, expr: attrsSrc.slice(at + 1, i), at: at + 1 };
+      }
+    }
+  }
+  return { literal: null, expr: null, at: null };
+};
+var spanOf = (blanked, symbol) => {
+  const decl = new RegExp(`\\b(?:const|let|var)\\s+${symbol}\\b`).exec(blanked);
+  if (!decl)
+    return null;
+  const eq = /=(?!=|>)/.exec(blanked.slice(decl.index + decl[0].length));
+  if (!eq)
+    return null;
+  const from = decl.index + decl[0].length + eq.index + 1;
+  let open = -1;
+  for (let i = from;i < blanked.length; i++) {
+    if (blanked[i] === "{" || blanked[i] === "[") {
+      open = i;
+      break;
+    }
+    if (blanked[i] === ";")
+      return null;
+  }
+  if (open < 0)
+    return null;
+  let depth = 0;
+  for (let i = open;i < blanked.length; i++) {
+    const ch = blanked[i];
+    if (ch === "{" || ch === "[")
+      depth += 1;
+    else if (ch === "}" || ch === "]") {
+      depth -= 1;
+      if (depth === 0)
+        return [open, i + 1];
+    }
+  }
+  return null;
+};
+var keysAtDepth1 = (blanked, objStart) => {
+  const keys = [];
+  const IDENT = /^["']?([A-Za-z_$][\w$]*)["']?\s*:/;
+  const COMPUTED = /^\[\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*\]\s*:/;
+  let depth = 0;
+  let i = objStart;
+  let pending = null;
+  while (i < blanked.length) {
+    const ch = blanked[i];
+    if (ch === "{" || ch === "[" || ch === "(") {
+      const computed = ch === "[" && depth === 1 ? COMPUTED.exec(blanked.slice(i, i + 120)) : null;
+      if (computed) {
+        if (pending)
+          keys.push({ ...pending, valueEnd: i });
+        pending = {
+          key: computed[1],
+          at: i,
+          keyAt: i + computed[0].indexOf(computed[1]),
+          valueAt: i + computed[0].length
+        };
+        i += computed[0].length;
+        continue;
+      }
+      depth += 1;
+      if (depth === 1) {
+        i += 1;
+        continue;
+      }
+    } else if (ch === "}" || ch === "]" || ch === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        if (pending)
+          keys.push({ ...pending, valueEnd: i });
+        break;
+      }
+    } else if (depth === 1) {
+      if (ch === "," && pending) {
+        keys.push({ ...pending, valueEnd: i });
+        pending = null;
+      }
+      const m = IDENT.exec(blanked.slice(i, i + 80));
+      const prev = blanked[i - 1] ?? "";
+      if (m && (i === objStart + 1 || `,{ 
+	\r`.includes(prev))) {
+        pending = { key: m[1], at: i, keyAt: i, valueAt: i + m[0].length };
+        i += m[0].length;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  return keys;
+};
+
+// src/census.ts
+var newCensus = () => ({
+  jsxTags: 0,
+  jsxMissed: [],
+  callsSeen: 0,
+  callsResolved: 0,
+  unknown: [],
+  patterned: [],
+  patternedCount: 0,
+  dynamic: []
+});
+var SAMPLES = 5;
+var sample = (into, line) => {
+  if (into.length < SAMPLES)
+    into.push(line);
+};
+
+// src/dialect.ts
+var DEFAULTS = {
+  helperCalls: [],
+  configKeys: ["screen"],
+  labelProps: ["label", "title"],
+  registryEntry: { name: "name", component: "component" },
+  guardKey: "if",
+  predicates: [],
+  exclude: [".test.", ".spec.", ".stories.", "__mocks__/"],
+  routeAliasFiles: [],
+  closureDepth: 6,
+  graphLabel: (path) => {
+    const folder = path.split("/").slice(-2, -1)[0] ?? "root";
+    const name = folder.replace(/(Stack)?Navigator$/, "") || folder;
+    return name.charAt(0).toLowerCase() + name.slice(1);
+  }
+};
+var checkPattern = (axis, re) => {
+  if (!re.global)
+    throw new Error(`[react-navigation] ${axis}: la regex doit porter le drapeau /g`);
+  if (new RegExp(`${re.source}|`).exec("").length - 1 < 1)
+    throw new Error(`[react-navigation] ${axis}: la regex doit avoir un groupe de capture`);
+  return re;
+};
+var resolveDialect = (dialect = {}) => {
+  const configured = new Set(Object.entries(dialect).filter(([, value]) => value !== undefined).map(([key]) => key));
+  for (const re of dialect.helperCalls ?? [])
+    checkPattern("helperCalls", re);
+  for (const p of dialect.predicates ?? [])
+    checkPattern(`predicates:${p.kind}`, p.pattern);
+  return {
+    helperCalls: dialect.helperCalls ?? DEFAULTS.helperCalls,
+    configKeys: dialect.configKeys ?? DEFAULTS.configKeys,
+    labelProps: dialect.labelProps ?? DEFAULTS.labelProps,
+    registryEntry: dialect.registryEntry ?? DEFAULTS.registryEntry,
+    guardKey: dialect.guardKey ?? DEFAULTS.guardKey,
+    predicates: dialect.predicates ?? DEFAULTS.predicates,
+    exclude: dialect.exclude ?? DEFAULTS.exclude,
+    routeAliasFiles: dialect.routeAliasFiles ?? DEFAULTS.routeAliasFiles,
+    closureDepth: dialect.closureDepth ?? DEFAULTS.closureDepth,
+    graphLabel: dialect.graphLabel ?? DEFAULTS.graphLabel,
+    configured
+  };
+};
+var bump = (counters, axis, n = 1) => {
+  counters[axis] = (counters[axis] ?? 0) + n;
+};
+var FACTORY = /\bcreate[A-Za-z]*Navigator\s*[(<]/;
+
+// src/ast.ts
+import ts from "typescript";
+var TYPE_POSITIONS = new Set([
+  ts.SyntaxKind.LiteralType,
+  ts.SyntaxKind.TypeAliasDeclaration,
+  ts.SyntaxKind.InterfaceDeclaration,
+  ts.SyntaxKind.EnumDeclaration
+]);
+var tagName = (node) => node.tagName.getText();
+var labelOf = (node, labelProps) => {
+  for (const attr of node.attributes.properties) {
+    if (!ts.isJsxAttribute(attr) || !ts.isIdentifier(attr.name))
+      continue;
+    if (!labelProps.includes(attr.name.text))
+      continue;
+    const value = attr.initializer;
+    if (value && ts.isStringLiteral(value))
+      return value.text;
+    if (value && ts.isJsxExpression(value) && value.expression && ts.isStringLiteral(value.expression))
+      return value.expression.text;
+  }
+  return "";
+};
+var declaredName = (node) => {
+  if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node))
+    return node.name ? node.name.text : null;
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name))
+    return node.name.text;
+  if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name))
+    return node.name.text;
+  if (ts.isPropertyAssignment(node) && (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name)) && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)))
+    return node.name.text;
+  return null;
+};
+var astIndex = (path, src) => {
+  const sourceFile = ts.createSourceFile(path, src, ts.ScriptTarget.Latest, true, path.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const nodeAt = (offset) => {
+    let deepest = sourceFile;
+    const descend = (node) => {
+      if (offset < node.getStart(sourceFile) || offset >= node.getEnd())
+        return;
+      deepest = node;
+      node.forEachChild(descend);
+    };
+    sourceFile.forEachChild(descend);
+    return deepest;
+  };
+  return {
+    typeOnly: (offset) => {
+      for (let node = nodeAt(offset);node; node = node.parent)
+        if (TYPE_POSITIONS.has(node.kind))
+          return true;
+      return false;
+    },
+    literalAt: (offset) => {
+      const node = nodeAt(offset);
+      return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) ? node.getStart(sourceFile) : offset;
+    },
+    context: (offset, labelProps) => {
+      for (let node = nodeAt(offset);node; node = node.parent) {
+        if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node))
+          return { trigger: tagName(node), label: labelOf(node, labelProps) };
+        const name = declaredName(node);
+        if (name)
+          return { trigger: name, label: "" };
+      }
+      return { trigger: "", label: "" };
+    }
+  };
+};
+
+// src/route-names.ts
+var collectEnums = (src, blanked, into) => {
+  for (const m of blanked.matchAll(/\benum\s+([A-Za-z_$][\w$]*)\s*\{/g)) {
+    const open = m.index + m[0].length - 1;
+    let depth = 0;
+    let end = blanked.length;
+    for (let i = open;i < blanked.length; i++) {
+      const ch = blanked[i];
+      if (ch === "{")
+        depth += 1;
+      else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          end = i;
+          break;
+        }
+      }
+    }
+    for (const member of src.slice(open + 1, end).matchAll(/([A-Za-z_$][\w$]*)\s*=\s*["']([^"']*)["']/g))
+      into.set(`${m[1]}.${member[1]}`, member[2]);
+  }
+};
+var REF_PATH = /^\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)/;
+var resolveRef = (names, ref) => {
+  let path = ref;
+  for (;; ) {
+    const hit = names.get(path);
+    if (hit !== undefined)
+      return hit;
+    const cut = path.lastIndexOf(".");
+    if (cut <= 0)
+      return null;
+    path = path.slice(0, cut);
+  }
+};
+var keyRoute = (key, keyAt, file, resolve) => {
+  const resolved = resolve(file, keyAt, keyAt + key.length, key);
+  return resolved ?? (key.includes(".") ? null : key);
+};
+var routeNameOf = (value, file, base, resolve) => {
+  if (value.literal !== null)
+    return value.literal;
+  if (value.expr === null || value.at === null)
+    return null;
+  const ref = REF_PATH.exec(value.expr);
+  return resolve(file, base + value.at, base + value.at + value.expr.length, ref?.[1] ?? value.expr);
+};
+var REFS_IN = /\b([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)/g;
+var collectAliases = (src, blanked, objStart, file, resolve, into, depth) => {
+  if (depth > 12)
+    return;
+  for (const { key, keyAt, valueAt, valueEnd } of keysAtDepth1(blanked, objStart)) {
+    const valueBlanked = blanked.slice(valueAt, valueEnd);
+    const nested = /\bscreens\s*:\s*\{/.exec(valueBlanked);
+    if (nested) {
+      collectAliases(src, blanked, valueAt + nested.index + nested[0].length - 1, file, resolve, into, depth + 1);
+      continue;
+    }
+    const route = keyRoute(key, keyAt, file, resolve);
+    if (!route)
+      continue;
+    for (const m of src.slice(valueAt, valueEnd).matchAll(REFS_IN)) {
+      const ref = m[1];
+      const at = valueAt + m.index;
+      const url = resolve(file, at, at + ref.length, ref);
+      if (url && !into.has(url))
+        into.set(url, route);
+      const cut = ref.lastIndexOf(".");
+      for (const path of cut > 0 ? [ref, ref.slice(0, cut)] : [ref])
+        if (!into.has(path))
+          into.set(path, route);
+    }
+  }
+};
+var isNested = (id) => id.split("|").length > 4;
+
+// src/nav-calls.ts
+var REF = String.raw`([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)`;
+var callPatterns = (d) => [
+  {
+    re: /\bnavigate\s*\(\s*["']([^"']+)["']/g,
+    kind: "navigate",
+    via: "imperative-call",
+    axis: "core"
+  },
+  {
+    re: new RegExp(String.raw`\bnavigate\s*\(\s*${REF}`, "g"),
+    kind: "navigate",
+    via: "imperative-call",
+    axis: "core",
+    ref: true
+  },
+  {
+    re: /\bpush\s*\(\s*["']([^"']+)["']/g,
+    kind: "push",
+    via: "imperative-call",
+    axis: "core"
+  },
+  {
+    re: new RegExp(String.raw`\bpush\s*\(\s*${REF}`, "g"),
+    kind: "push",
+    via: "imperative-call",
+    axis: "core",
+    ref: true
+  },
+  {
+    re: /\breplace\s*\(\s*["']([^"']+)["']/g,
+    kind: "replace",
+    via: "imperative-call",
+    axis: "core"
+  },
+  {
+    re: new RegExp(String.raw`\breplace\s*\(\s*${REF}`, "g"),
+    kind: "replace",
+    via: "imperative-call",
+    axis: "core",
+    ref: true
+  },
+  {
+    re: /\breset\s*\(\s*["']([^"']+)["']/g,
+    kind: "reset",
+    via: "imperative-call",
+    axis: "core"
+  },
+  {
+    re: new RegExp(String.raw`\breset\s*\(\s*${REF}`, "g"),
+    kind: "reset",
+    via: "imperative-call",
+    axis: "core",
+    ref: true
+  },
+  {
+    re: /navigateTo\s*=\s*\{\{\s*screen\s*:\s*["']([^"']+)["']/g,
+    kind: "link",
+    via: "declarative-link",
+    axis: "core"
+  },
+  {
+    re: new RegExp(String.raw`navigateTo\s*=\s*\{\{\s*screen\s*:\s*${REF}`, "g"),
+    kind: "link",
+    via: "declarative-link",
+    axis: "core",
+    ref: true
+  },
+  ...d.helperCalls.map((re) => ({
+    re,
+    kind: "navigate",
+    via: "helper",
+    axis: "helperCalls"
+  })),
+  ...d.configKeys.flatMap((key) => [
+    {
+      re: new RegExp(`\\b${key}\\s*:\\s*["']([^"']+)["']`, "g"),
+      kind: "navigate",
+      via: "config",
+      axis: "configKeys"
+    },
+    {
+      re: new RegExp(String.raw`\b${key}\s*:\s*${REF}`, "g"),
+      kind: "navigate",
+      via: "config",
+      axis: "configKeys",
+      ref: true
+    }
+  ])
+];
+var CENSUS_CALL = /\bnavigate\s*\(/g;
+var PATTERN_LIMIT = 8;
+var firstArgEnd = (blanked, from) => {
+  let depth = 0;
+  for (let i = from;i < blanked.length; i++) {
+    const ch = blanked[i];
+    if (ch === "(" || ch === "[" || ch === "{")
+      depth += 1;
+    else if (ch === ")" || ch === "]" || ch === "}") {
+      if (depth === 0)
+        return i;
+      depth -= 1;
+    } else if (ch === "," && depth === 0)
+      return i;
+  }
+  return blanked.length;
+};
+var NAV_CALL = /\b(navigate|push|replace|reset)\s*\(/g;
+var ROUTE_ENTRY = /\bname\s*:\s*["']([^"']+)["']/g;
+var ROUTE_TERNARY = /\?\s*["']([^"']+)["']\s*:\s*["']([^"']+)["']/g;
+var argsEnd = (blanked, from) => {
+  let depth = 0;
+  for (let i = from;i < blanked.length; i++) {
+    const ch = blanked[i];
+    if (ch === "(")
+      depth += 1;
+    else if (ch === ")") {
+      if (depth === 0)
+        return i;
+      depth -= 1;
+    }
+  }
+  return blanked.length;
+};
+var spreadTargets = (src, blanked, routeNames) => {
+  const out = [];
+  for (const call of blanked.matchAll(NAV_CALL)) {
+    const from = call.index + call[0].length;
+    const region = src.slice(from, argsEnd(blanked, from));
+    for (const re of [ROUTE_ENTRY, ROUTE_TERNARY])
+      for (const m of region.matchAll(re))
+        for (const route of m.slice(1))
+          if (route && routeNames.has(route))
+            out.push({
+              route,
+              index: call.index,
+              kind: call[1]
+            });
+  }
+  return out;
+};
+var callSitesIn = (src, blanked, path, routeNames, d, resolve, counters, census, classify) => {
+  const out = [];
+  const seen = new Set;
+  let parsed = null;
+  const ast = () => parsed ??= astIndex(path, src);
+  for (const { re, kind, via, axis, ref } of callPatterns(d)) {
+    re.lastIndex = 0;
+    for (const m of src.matchAll(re)) {
+      const captured = m[1];
+      const at = m.index + m[0].lastIndexOf(captured);
+      const route = ref ? resolve(path, at, at + captured.length, captured) : captured;
+      if (!route || !routeNames.has(route))
+        continue;
+      if (ast().typeOnly(at))
+        continue;
+      const key = `${route}|${ast().literalAt(at)}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      const line = lineAt(src, m.index);
+      bump(counters, axis);
+      out.push({
+        route,
+        file: path,
+        line,
+        kind,
+        via,
+        ...ast().context(at, d.labelProps)
+      });
+    }
+  }
+  for (const hit of spreadTargets(src, blanked, routeNames)) {
+    if (ast().typeOnly(hit.index))
+      continue;
+    const key = `${hit.route}|${ast().literalAt(hit.index)}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    const line = lineAt(src, hit.index);
+    bump(counters, "core");
+    out.push({
+      route: hit.route,
+      file: path,
+      line,
+      kind: hit.kind,
+      via: "imperative-call",
+      ...ast().context(hit.index, d.labelProps)
+    });
+  }
+  CENSUS_CALL.lastIndex = 0;
+  for (const call of blanked.matchAll(CENSUS_CALL)) {
+    const from = call.index + call[0].length;
+    if (ast().typeOnly(from))
+      continue;
+    census.callsSeen += 1;
+    let start = from;
+    while (start < src.length && /\s/.test(src[start]))
+      start += 1;
+    const end = firstArgEnd(blanked, from);
+    const expr = src.slice(start, end).trim();
+    if (expr.length === 0)
+      continue;
+    const ref = REF_PATH.exec(expr);
+    const verdict = classify(path, start, start + expr.length, ref?.[1] ?? expr);
+    const where = `${path}:${lineAt(src, call.index) + 1}  ${expr.replace(/\s+/g, " ").slice(0, 60)}`;
+    if (verdict === "resolved")
+      census.callsResolved += 1;
+    else if (verdict === "unknown")
+      sample(census.unknown, where);
+    else if (verdict === "pattern") {
+      census.patternedCount += 1;
+      sample(census.patterned, where);
+    } else
+      sample(census.dynamic, where);
+  }
+  return out;
+};
+var fileOfSymbolId = (id) => id.split("|")[2] ?? "";
+
+// src/registrations.ts
+var unwrapComponent = (expr) => {
+  let current = expr.trim();
+  for (let guard = 0;guard < 8; guard++) {
+    const call = /^([A-Za-z_$][\w$.]*)\s*\(/.exec(current);
+    if (!call)
+      break;
+    let depth = 0;
+    let start = -1;
+    let end = -1;
+    for (let i = call[0].length - 1;i < current.length; i++) {
+      const ch = current[i];
+      if (ch === "(") {
+        depth += 1;
+        if (depth === 1)
+          start = i + 1;
+      } else if (ch === ")") {
+        depth -= 1;
+        if (depth === 0) {
+          end = i;
+          break;
+        }
+      }
+    }
+    if (start < 0 || end < 0)
+      break;
+    const inner = current.slice(start, end).trim();
+    if (!inner || /^\(?\s*\)/.test(inner))
+      break;
+    current = inner;
+  }
+  const ident = /^([A-Za-z_$][\w$.]*)/.exec(current);
+  return ident ? ident[1].split(".").pop() ?? null : null;
+};
+var LAZY_MODULE = /\brequire\s*(?:<[^>]*>)?\s*\(\s*["']([^"']+)["']/;
+var lazyLoaders = (src, blanked) => {
+  const out = new Map;
+  for (const decl of blanked.matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/g)) {
+    const from = decl.index + decl[0].length;
+    const semi = blanked.indexOf(";", from);
+    const module = LAZY_MODULE.exec(src.slice(from, semi < 0 ? from + 400 : semi));
+    if (module)
+      out.set(decl[1], module[1]);
+  }
+  return out;
+};
+var jsxComponent = (component, getter, loaders) => {
+  if (component.expr)
+    return unwrapComponent(component.expr);
+  if (!getter.expr)
+    return null;
+  const inline = LAZY_MODULE.exec(getter.expr);
+  if (inline)
+    return `module:${inline[1]}`;
+  const ident = /^\s*([A-Za-z_$][\w$]*)\s*$/.exec(getter.expr);
+  const viaLoader = ident ? loaders.get(ident[1]) : undefined;
+  return viaLoader ? `module:${viaLoader}` : unwrapComponent(getter.expr);
+};
+var enclosingDecl = (blanked, before) => {
+  let last = null;
+  for (const m of blanked.slice(0, before).matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/g))
+    last = m[1];
+  return last;
+};
+var readEntry = (segment, d) => {
+  const compKey = `(?:screen|${d.registryEntry.component})`;
+  const comp = new RegExp(`\\b${compKey}\\s*:\\s*([\\s\\S]{0,200}?)(?:,\\s*\\w+\\s*:|\\}|$)`).exec(segment);
+  const guard = new RegExp(`\\b${d.guardKey}\\s*:\\s*([A-Za-z_$][\\w$.]*)`).exec(segment);
+  return {
+    component: comp ? unwrapComponent(comp[1]) : null,
+    guard: guard ? guard[1] : null,
+    hasOptions: /\boptions\s*:/.test(segment)
+  };
+};
+var fromRegistries = (src, blanked, d, file, resolve) => {
+  const out = [];
+  for (const m of blanked.matchAll(/\bscreens\s*:\s*\{/g)) {
+    const objStart = m.index + m[0].length - 1;
+    for (const { key, at, keyAt, valueAt, valueEnd } of keysAtDepth1(blanked, objStart)) {
+      const segment = src.slice(valueAt, valueEnd);
+      if (!new RegExp(`\\b(?:screen|${d.registryEntry.component})\\s*:\\s*[A-Za-z_$]`).test(segment))
+        continue;
+      const route = keyRoute(key, keyAt, file, resolve);
+      if (!route)
+        continue;
+      out.push({
+        route,
+        line: lineAt(src, at),
+        shape: "static-config",
+        ...readEntry(segment, d)
+      });
+    }
+  }
+  for (const decl of blanked.matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g)) {
+    const span = spanOf(blanked, decl[1]);
+    if (!span)
+      continue;
+    const [start, end] = span;
+    const segment = src.slice(start, end);
+    if (!new RegExp(`\\b${d.registryEntry.component}\\s*:`).test(segment))
+      continue;
+    for (const m of segment.matchAll(new RegExp(`\\b${d.registryEntry.name}\\s*:\\s*["']([^"']+)["']`, "g"))) {
+      const tail = segment.slice(m.index + m[0].length, m.index + m[0].length + 500);
+      out.push({
+        route: m[1],
+        line: lineAt(src, start + m.index),
+        shape: "array-config",
+        ...readEntry(tail, d)
+      });
+    }
+  }
+  return out;
+};
+var fromRegistryLiterals = (src, blanked, d, file, resolve, registries) => {
+  const out = [];
+  for (const { start, viaCall } of registries) {
+    if (blanked[start] !== "{")
+      continue;
+    const graph = viaCall ? enclosingDecl(blanked, start) ?? undefined : undefined;
+    for (const { key, at, keyAt, valueAt, valueEnd } of keysAtDepth1(blanked, start)) {
+      const route = keyRoute(key, keyAt, file, resolve);
+      if (!route)
+        continue;
+      const segment = src.slice(valueAt, valueEnd);
+      const lazy = LAZY_MODULE.exec(segment);
+      const entry = readEntry(segment, d);
+      out.push({
+        route,
+        line: lineAt(src, at),
+        shape: viaCall ? "factory-arg" : "const-object",
+        component: lazy ? `module:${lazy[1]}` : entry.component ?? unwrapComponent(segment),
+        guard: entry.guard,
+        hasOptions: entry.hasOptions,
+        graph
+      });
+    }
+  }
+  return out;
+};
+var fromJsx = (src, blanked, d, file, resolve, census) => {
+  const out = [];
+  const loaders = lazyLoaders(src, blanked);
+  for (const m of blanked.matchAll(/<\s*[\w.]*\.Screen\b/g)) {
+    let depth = 0;
+    let i = m.index + m[0].length;
+    for (;i < blanked.length; i++) {
+      const ch = blanked[i];
+      if (ch === "{")
+        depth += 1;
+      else if (ch === "}")
+        depth -= 1;
+      else if (ch === ">" && depth === 0)
+        break;
+    }
+    const from = m.index + m[0].length;
+    const attrs = src.slice(from, i);
+    const attrsBlanked = blanked.slice(from, i);
+    census.jsxTags += 1;
+    const route = routeNameOf(topLevelAttr(attrs, attrsBlanked, "name"), file, from, resolve);
+    if (!route) {
+      const attr = topLevelAttr(attrs, attrsBlanked, "name");
+      sample(census.jsxMissed, `${file}:${lineAt(src, m.index) + 1}  name={${attr.expr?.trim().slice(0, 50) ?? "?"}}`);
+      continue;
+    }
+    out.push({
+      route,
+      line: lineAt(src, m.index),
+      shape: "inline-jsx",
+      component: jsxComponent(topLevelAttr(attrs, attrsBlanked, "component"), topLevelAttr(attrs, attrsBlanked, "getComponent"), loaders),
+      guard: null,
+      hasOptions: /\boptions\s*=/.test(attrsBlanked)
+    });
+  }
+  return out;
+};
+
+// src/type-index.ts
+import ts2 from "typescript";
+var createTypeIndex = (projectRoot, files) => {
+  const configPath = ts2.findConfigFile(projectRoot, ts2.sys.fileExists, "tsconfig.json");
+  if (!configPath)
+    return null;
+  const started = Date.now();
+  const config = ts2.readConfigFile(configPath, ts2.sys.readFile);
+  if (config.error)
+    return null;
+  const parsed = ts2.parseJsonConfigFileContent(config.config, ts2.sys, projectRoot);
+  const rootNames = files.map((f) => `${projectRoot}/${f}`);
+  const program = ts2.createProgram({
+    rootNames,
+    options: { ...parsed.options, noEmit: true }
+  });
+  const checker = program.getTypeChecker();
+  const buildMs = Date.now() - started;
+  if (program.getSourceFiles().length === 0)
+    return null;
+  const sources = new Map;
+  const sourceOf = (file) => {
+    const key = `${projectRoot}/${file}`;
+    if (!sources.has(key))
+      sources.set(key, program.getSourceFile(key));
+    return sources.get(key);
+  };
+  const nodeIn = (sf, start, end) => {
+    const deepest = (node) => {
+      for (const child of node.getChildren(sf))
+        if (child.getFullStart() <= start && start < child.getEnd())
+          return deepest(child);
+      return node;
+    };
+    let node = deepest(sf);
+    if (node.getStart(sf) >= end)
+      return null;
+    while (node.parent && node.parent.getStart(sf) >= start && node.parent.getEnd() <= end)
+      node = node.parent;
+    return node;
+  };
+  const patternsOf = (type, out) => {
+    if (type.isUnion()) {
+      for (const member of type.types)
+        patternsOf(member, out);
+      return;
+    }
+    if (type.flags & ts2.TypeFlags.TemplateLiteral) {
+      const texts = type.texts;
+      out.push(texts.join("*"));
+    } else if (type.isStringLiteral())
+      out.push(type.value);
+  };
+  const typeAt = (file, start, end) => {
+    const sf = sourceOf(file);
+    if (!sf)
+      return null;
+    const node = nodeIn(sf, start, end);
+    return node ? checker.getTypeAtLocation(node) : null;
+  };
+  const keyLiteral = (name) => {
+    if (ts2.isComputedPropertyName(name)) {
+      const type = checker.getTypeAtLocation(name.expression);
+      return type.isStringLiteral() ? type.value : null;
+    }
+    return ts2.isStringLiteral(name) ? name.text : null;
+  };
+  const callable = (value) => checker.getTypeAtLocation(value).getCallSignatures().length > 0;
+  const isRegistry = (obj) => {
+    const props = obj.properties.filter(ts2.isPropertyAssignment);
+    if (props.length === 0 || props.length !== obj.properties.length)
+      return false;
+    let callables = 0;
+    for (const prop of props) {
+      if (keyLiteral(prop.name) === null)
+        return false;
+      if (callable(prop.initializer))
+        callables += 1;
+    }
+    return callables * 2 >= props.length;
+  };
+  const effectiveParent = (node) => {
+    let current = node.parent;
+    while (current && (ts2.isAsExpression(current) || ts2.isSatisfiesExpression(current) || ts2.isParenthesizedExpression(current)))
+      current = current.parent;
+    return current;
+  };
+  return {
+    sourceFiles: program.getSourceFiles().length,
+    buildMs,
+    registryLiterals(file) {
+      const sf = sourceOf(file);
+      if (!sf)
+        return [];
+      const out = [];
+      const visit = (node) => {
+        if (ts2.isObjectLiteralExpression(node) && isRegistry(node)) {
+          const parent = effectiveParent(node);
+          out.push({
+            start: node.getStart(sf),
+            end: node.getEnd(),
+            viaCall: !!parent && ts2.isCallExpression(parent)
+          });
+          return;
+        }
+        ts2.forEachChild(node, visit);
+      };
+      visit(sf);
+      return out;
+    },
+    literalIn(file, start, end) {
+      const type = typeAt(file, start, end);
+      return type?.isStringLiteral() ? type.value : null;
+    },
+    patternIn(file, start, end) {
+      const type = typeAt(file, start, end);
+      if (!type)
+        return null;
+      const out = [];
+      patternsOf(type, out);
+      return out.length > 0 && !type.isStringLiteral() ? out : null;
+    }
+  };
+};
+
+// src/collect.ts
+var collect = async (deps, d) => {
+  const { source, projectRoot, graph, workspace } = deps;
+  const counters = {};
+  const census = newCensus();
+  const paths = (await source.listFiles()).filter((p) => !d.exclude.some((x) => p.includes(x)));
+  const sources = new Map;
+  const factoryFiles = [];
+  const names = new Map;
+  for (const path of paths) {
+    const src = await source.read(path);
+    sources.set(path, src);
+    if (FACTORY.test(src))
+      factoryFiles.push(path);
+    if (src.includes("enum "))
+      collectEnums(src, stripNoise(src), names);
+  }
+  const types = createTypeIndex(projectRoot, paths);
+  const aliases = new Map;
+  const literalOf = (file, start, end, text) => types?.literalIn(file, start, end) ?? resolveRef(names, text);
+  const resolve = (file, start, end, text) => {
+    const byType = types?.literalIn(file, start, end) ?? null;
+    if (byType !== null) {
+      bump(counters, "types");
+      return byType;
+    }
+    const byTable = resolveRef(names, text);
+    if (byTable !== null)
+      bump(counters, "tables");
+    return byTable;
+  };
+  for (const fragment of d.routeAliasFiles) {
+    for (const path of paths) {
+      if (!path.endsWith(fragment))
+        continue;
+      const src = sources.get(path);
+      const blanked = stripNoise(src);
+      for (const m of blanked.matchAll(/\bscreens\s*:\s*\{/g))
+        collectAliases(src, blanked, m.index + m[0].length - 1, path, resolve, aliases, 0);
+    }
+  }
+  bump(counters, "routeAliasFiles", aliases.size);
+  const dirs = new Set(factoryFiles.map((p) => p.split("/").slice(0, -1).join("/")));
+  const found = [];
+  for (const path of paths) {
+    if (!dirs.has(path.split("/").slice(0, -1).join("/")))
+      continue;
+    const src = sources.get(path);
+    const blanked = stripNoise(src);
+    const regs = [
+      ...fromRegistries(src, blanked, d, path, resolve),
+      ...fromRegistryLiterals(src, blanked, d, path, resolve, types?.registryLiterals(path) ?? []),
+      ...fromJsx(src, blanked, d, path, resolve, census)
+    ];
+    if (regs.length === 0)
+      continue;
+    bump(counters, "registries", regs.filter((r) => r.shape !== "inline-jsx").length);
+    for (const reg of regs)
+      found.push({ graph: reg.graph ?? d.graphLabel(path), file: path, reg });
+  }
+  const duplicates = [];
+  {
+    const seen = new Set;
+    let write = 0;
+    for (const entry of found) {
+      const key = `${entry.graph}|${entry.reg.route}`;
+      if (seen.has(key)) {
+        duplicates.push(`${key} (${entry.file})`);
+        continue;
+      }
+      seen.add(key);
+      found[write++] = entry;
+    }
+    found.length = write;
+  }
+  const navigatorFiles = [...new Set(found.map((f) => f.file))];
+  const byFile = new Map;
+  const ambiguous = new Set;
+  for (const row of await graph.componentCandidates(navigatorFiles)) {
+    if (!row.name || !row.symbolId)
+      continue;
+    if (isNested(row.symbolId))
+      continue;
+    const index = byFile.get(row.file) ?? new Map;
+    const previous = index.get(row.name);
+    if (previous && previous !== row.symbolId)
+      ambiguous.add(`${row.file}|${row.name}`);
+    else
+      index.set(row.name, row.symbolId);
+    byFile.set(row.file, index);
+  }
+  const filePaths = await graph.filePaths();
+  const filePathSet = new Set(filePaths);
+  const normalize = (path) => {
+    const out = [];
+    for (const part of path.split("/")) {
+      if (part === "." || part === "")
+        continue;
+      if (part === "..")
+        out.pop();
+      else
+        out.push(part);
+    }
+    return out.join("/");
+  };
+  const EXTENSIONS = [".tsx", ".ts", "/index.tsx", "/index.ts"];
+  const fileOfModule = (fromFile, spec) => {
+    const base = spec.startsWith(".") ? normalize(`${fromFile.split("/").slice(0, -1).join("/")}/${spec}`) : spec.replace(/^@[\w-]*\//, "");
+    for (const ext of EXTENSIONS)
+      if (filePathSet.has(base + ext))
+        return base + ext;
+    for (const ext of EXTENSIONS) {
+      const suffix = `/${base}${ext}`;
+      const hit = filePaths.find((p) => p.endsWith(suffix));
+      if (hit)
+        return hit;
+    }
+    return null;
+  };
+  const moduleFiles = new Map;
+  for (const { file, reg } of found) {
+    if (!reg.component?.startsWith("module:"))
+      continue;
+    const key = `${file}|${reg.component}`;
+    if (moduleFiles.has(key))
+      continue;
+    const path = fileOfModule(file, reg.component.slice("module:".length));
+    if (path)
+      moduleFiles.set(key, path);
+  }
+  const mainSymbol = new Map;
+  {
+    const rows = await graph.declaredSymbols([
+      ...new Set(moduleFiles.values())
+    ]);
+    const byPath = new Map;
+    for (const row of rows) {
+      const list = byPath.get(row.file) ?? [];
+      list.push(row);
+      byPath.set(row.file, list);
+    }
+    for (const [path, symbols] of byPath) {
+      const stem = path.split("/").pop().replace(/\.(tsx|ts)$/, "");
+      const values = symbols.filter((s) => s.type !== "type" && s.type !== "interface");
+      const hit = values.find((s) => s.name === stem) ?? (path.endsWith("/index.tsx") || path.endsWith("/index.ts") ? values.find((s) => s.name === path.split("/").slice(-2, -1)[0]) : undefined) ?? (values.length === 1 ? values[0] : undefined);
+      if (hit)
+        mainSymbol.set(path, hit.symbolId);
+    }
+  }
+  const screenKey = (graphName, route) => `${workspace}|${graphName}|${route}`;
+  const routeKey = (route) => `${workspace}|${route}`;
+  const componentOf = new Map;
+  for (const { graph: graphName, file, reg } of found) {
+    const key = screenKey(graphName, reg.route);
+    const lazy = reg.component?.startsWith("module:") ? mainSymbol.get(moduleFiles.get(`${file}|${reg.component}`) ?? "") : undefined;
+    componentOf.set(key, lazy ?? (reg.component ? byFile.get(file)?.get(reg.component) ?? null : null));
+  }
+  const routeNames = new Set(found.map((f) => f.reg.route));
+  const resolveTarget = (file, start, end, text) => {
+    const literal = resolve(file, start, end, text);
+    if (literal !== null && routeNames.has(literal))
+      return literal;
+    const viaUrl = literal !== null ? aliases.get(literal) : undefined;
+    if (viaUrl) {
+      bump(counters, "aliasUrl");
+      return viaUrl;
+    }
+    const viaRef = resolveRef(aliases, text);
+    if (viaRef)
+      bump(counters, "aliasRef");
+    return viaRef;
+  };
+  const classify = (file, start, end, text) => {
+    const literal = literalOf(file, start, end, text);
+    if (literal !== null)
+      return routeNames.has(literal) || aliases.has(literal) || resolveRef(aliases, text) ? "resolved" : "unknown";
+    if (resolveRef(aliases, text))
+      return "resolved";
+    const patterns = types?.patternIn(file, start, end);
+    return patterns && patterns.length <= PATTERN_LIMIT ? "pattern" : "dynamic";
+  };
+  const callSites = [];
+  for (const [path, src] of sources) {
+    callSites.push(...callSitesIn(src, stripNoise(src), path, routeNames, d, resolveTarget, counters, census, classify));
+  }
+  const adjacency = await graph.adjacency();
+  const closureCache = new Map;
+  const filesReachableFrom = (symbolId) => {
+    const cached = closureCache.get(symbolId);
+    if (cached)
+      return cached;
+    const files = new Set([fileOfSymbolId(symbolId)]);
+    const seen = new Set([symbolId]);
+    let frontier = [symbolId];
+    for (let depth = 0;depth < d.closureDepth && frontier.length; depth++) {
+      const next = [];
+      for (const node of frontier) {
+        for (const target of adjacency.get(node) ?? []) {
+          if (seen.has(target))
+            continue;
+          seen.add(target);
+          files.add(fileOfSymbolId(target));
+          next.push(target);
+        }
+      }
+      frontier = next;
+    }
+    closureCache.set(symbolId, files);
+    return files;
+  };
+  const callsByFile = new Map;
+  for (const cs of callSites) {
+    const list = callsByFile.get(cs.file);
+    if (list)
+      list.push(cs);
+    else
+      callsByFile.set(cs.file, [cs]);
+  }
+  const screensByRoute = new Map;
+  for (const { graph: graphName, reg } of found) {
+    const key = screenKey(graphName, reg.route);
+    const list = screensByRoute.get(reg.route);
+    if (list)
+      list.push(key);
+    else
+      screensByRoute.set(reg.route, [key]);
+  }
+  const graphLabels = new Set(found.map((f) => f.graph));
+  const screens = [];
+  const renders = [];
+  const unlinked = [];
+  const mounts = [];
+  for (const { graph: graphName, file, reg } of found) {
+    const key = screenKey(graphName, reg.route);
+    const symbolId = componentOf.get(key) ?? null;
+    screens.push({
+      id: key,
+      route: reg.route,
+      graph: graphName,
+      file,
+      line: reg.line,
+      shape: reg.shape,
+      guard: reg.guard ?? "",
+      hasOptions: reg.hasOptions,
+      component: symbolId ?? ""
+    });
+    if (symbolId)
+      renders.push({ screen: key, symbol: symbolId });
+    else if (reg.component && graphLabels.has(reg.component))
+      mounts.push(reg.route);
+    else
+      unlinked.push(`${reg.route} (${graphName})`);
+  }
+  const predicateIndex = new Map;
+  const gates = [];
+  for (const { graph: graphName, reg } of found) {
+    const key = screenKey(graphName, reg.route);
+    const screenPredicates = [];
+    if (reg.guard)
+      screenPredicates.push({ name: reg.guard, kind: "guard" });
+    const symbolId = componentOf.get(key);
+    const componentFile = symbolId ? symbolId.split("|")[2] : undefined;
+    const componentSrc = componentFile ? sources.get(componentFile) : undefined;
+    if (componentSrc) {
+      for (const { kind, pattern } of d.predicates) {
+        pattern.lastIndex = 0;
+        for (const m of componentSrc.matchAll(pattern)) {
+          screenPredicates.push({ name: m[1], kind });
+          bump(counters, "predicates");
+        }
+      }
+    }
+    for (const predicate of screenPredicates) {
+      const pkey = `${workspace}|${predicate.kind}|${predicate.name}`;
+      predicateIndex.set(pkey, predicate);
+      gates.push({ screen: key, predicate: pkey });
+    }
+  }
+  const navRows = [];
+  const attributedFiles = new Set;
+  for (const { graph: graphName, reg } of found) {
+    const key = screenKey(graphName, reg.route);
+    const symbolId = componentOf.get(key);
+    if (!symbolId)
+      continue;
+    const componentFile = symbolId.split("|")[2];
+    for (const file of filesReachableFrom(symbolId)) {
+      for (const cs of callsByFile.get(file) ?? []) {
+        if (cs.route === reg.route)
+          continue;
+        attributedFiles.add(file);
+        navRows.push({
+          screen: key,
+          route: routeKey(cs.route),
+          kind: cs.kind,
+          via: cs.via,
+          file: cs.file,
+          line: cs.line,
+          trigger: cs.trigger,
+          label: cs.label,
+          own: cs.file === componentFile,
+          owners: 0
+        });
+      }
+    }
+  }
+  const ownedSites = new Set;
+  for (const row of navRows)
+    if (row.own)
+      ownedSites.add(`${row.route}|${row.file}|${row.line}`);
+  const edges = navRows.filter((row) => row.own || !ownedSites.has(`${row.route}|${row.file}|${row.line}`));
+  const borrowed = navRows.length - edges.length;
+  const siteKey = (row) => `${row.file}|${row.line}|${row.route}`;
+  const siteOwners = new Map;
+  for (const row of edges)
+    siteOwners.set(siteKey(row), (siteOwners.get(siteKey(row)) ?? 0) + 1);
+  for (const row of edges)
+    row.owners = siteOwners.get(siteKey(row)) ?? 1;
+  let orphanCalls = 0;
+  for (const cs of callSites)
+    if (!attributedFiles.has(cs.file))
+      orphanCalls += 1;
+  return {
+    routes: [...screensByRoute].map(([route, keys]) => ({
+      id: routeKey(route),
+      name: route,
+      registrations: keys.length
+    })),
+    screens,
+    renders,
+    predicates: [...predicateIndex].map(([id, p]) => ({
+      id,
+      name: p.name,
+      kind: p.kind
+    })),
+    gates,
+    edges,
+    report: {
+      counters,
+      census,
+      duplicates,
+      unlinked,
+      mounts,
+      ambiguous: [...ambiguous],
+      multi: [...screensByRoute].filter(([, ids]) => ids.length > 1).map(([route]) => route),
+      orphanCalls,
+      borrowed,
+      factoryFiles: factoryFiles.length,
+      callSites: callSites.length,
+      rendered: renders.length,
+      gates: gates.length,
+      typeIndex: types ? { sourceFiles: types.sourceFiles, buildMs: types.buildMs } : null,
+      adjacencySize: adjacency.size
+    }
+  };
+};
+
+// src/graph-reader.ts
+var cypherReader = (db, workspace) => ({
+  async adjacency() {
+    const out = new Map;
+    const rows = await db.query`
+			MATCH (a:Symbol)-[:USES]->(b:Symbol) WHERE a.workspace = ${workspace}
+			RETURN a.id AS s, b.id AS t`;
+    for (const row of rows) {
+      const list = out.get(row.s);
+      if (list)
+        list.push(row.t);
+      else
+        out.set(row.s, [row.t]);
+    }
+    return out;
+  },
+  async componentCandidates(files) {
+    if (files.length === 0)
+      return [];
+    return db.query`
+			MATCH (f:File)-[:DECLARES]->(owner:Symbol)
+			WHERE f.workspace = ${workspace} AND f.path IN ${files}
+			OPTIONAL MATCH (owner)-[:USES]->(used:Symbol)
+			UNWIND [owner, used] AS c
+			WITH f.path AS file, c
+			WHERE c IS NOT NULL
+			RETURN DISTINCT file, c.name AS name, c.id AS symbolId`;
+  },
+  async filePaths() {
+    const rows = await db.query`
+			MATCH (f:File) WHERE f.workspace = ${workspace} RETURN f.path AS path`;
+    return rows.map((r) => r.path);
+  },
+  async declaredSymbols(files) {
+    if (files.length === 0)
+      return [];
+    return db.query`
+			MATCH (f:File)-[:DECLARES]->(s:Symbol)
+			WHERE f.workspace = ${workspace} AND f.path IN ${files}
+			RETURN f.path AS file, s.name AS name, s.id AS symbolId, s.type AS type`;
+  }
+});
+
+// src/payload.ts
+var OPEN = { tags: [], description: null, data: {} };
+var toPayload = (model) => {
+  const routeOf = new Map(model.routes.map((r) => [r.name, r.id]));
+  const nodes = [
+    ...model.routes.map((r) => ({
+      _label: "Route",
+      id: r.id,
+      name: r.name,
+      registrations: r.registrations,
+      ...OPEN
+    })),
+    ...model.screens.map((s) => ({
+      _label: "Screen",
+      id: s.id,
+      route: s.route,
+      graph: s.graph,
+      file: s.file,
+      line: s.line,
+      shape: s.shape,
+      guard: s.guard,
+      hasOptions: s.hasOptions,
+      component: s.component,
+      ...OPEN
+    })),
+    ...model.predicates.map((p) => ({
+      _label: "Predicate",
+      id: p.id,
+      name: p.name,
+      kind: p.kind,
+      ...OPEN
+    }))
+  ];
+  const edges = [
+    ...model.screens.map((s) => ({
+      _label: "SERVES",
+      from: "Route",
+      to: "Screen",
+      fromId: routeOf.get(s.route) ?? "",
+      toId: s.id,
+      ...OPEN
+    })),
+    ...model.renders.map((r) => ({
+      _label: "RENDERS",
+      from: "Screen",
+      to: "Symbol",
+      fromId: r.screen,
+      toId: r.symbol,
+      ...OPEN
+    })),
+    ...model.gates.map((g) => ({
+      _label: "GATED_BY",
+      from: "Screen",
+      to: "Predicate",
+      fromId: g.screen,
+      toId: g.predicate,
+      ...OPEN
+    })),
+    ...model.edges.map((e) => ({
+      _label: "NAVIGATES_TO",
+      from: "Screen",
+      to: "Route",
+      fromId: e.screen,
+      toId: e.route,
+      kind: e.kind,
+      via: e.via,
+      file: e.file,
+      line: e.line,
+      trigger: e.trigger,
+      label: e.label,
+      own: e.own,
+      owners: e.owners,
+      ...OPEN
+    }))
+  ];
+  return { nodes, edges };
+};
+
+// src/react-navigation.contributor.ts
+var AXES = [
+  "core",
+  "helperCalls",
+  "configKeys",
+  "predicates",
+  "types",
+  "tables",
+  "registries",
+  "routeAliasFiles",
+  "aliasUrl",
+  "aliasRef"
+];
+var logReport = (report) => {
+  const { counters, census } = report;
+  if (report.typeIndex)
+    console.log(`[react-navigation] index de types : ${report.typeIndex.sourceFiles} fichiers en ${report.typeIndex.buildMs} ms`);
+  console.log(`[react-navigation] ${report.adjacencySize} symboles sources dans l'adjacence`);
+  console.log(`[react-navigation] dialecte : ${AXES.map((a) => `${a} ${counters[a] ?? 0}`).join(" \xB7 ")}`);
+  const pct = (n, total) => total === 0 ? "\u2014" : `${Math.round(n / total * 100)} %`;
+  const missedCalls = census.callsSeen - census.callsResolved;
+  console.log(`[react-navigation] couverture des appels \`navigate\` : ` + `${census.callsResolved}/${census.callsSeen} (${pct(census.callsResolved, census.callsSeen)})`);
+  if (missedCalls > 0) {
+    const opaque = missedCalls - census.patternedCount;
+    console.log(`  ${missedCalls} sans ar\xEAte : ${census.unknown.length > 0 ? `${census.unknown.length}+ hors registre \xB7 ` : ""}` + `${census.patternedCount} avec motif d'URL \xB7 ${opaque} opaques`);
+    if (census.unknown.length > 0) {
+      console.log(`  cible lisible mais absente du registre \u2014 inscription probablement rat\xE9e :`);
+      for (const line of census.unknown)
+        console.log(`    ${line}`);
+    }
+    if (census.patterned.length > 0) {
+      console.log(`  sans litt\xE9ral mais avec motif d'URL \u2014 joignable par la config linking :`);
+      for (const line of census.patterned)
+        console.log(`    ${line}`);
+    }
+    if (census.dynamic.length > 0) {
+      console.log(`  opaque \u2014 irr\xE9ductible :`);
+      for (const line of census.dynamic)
+        console.log(`    ${line}`);
+    }
+  }
+  console.log(`[react-navigation] balises <*.Screen> : ${census.jsxTags} vues, ` + `${census.jsxTags - census.jsxMissed.length} exploit\xE9es`);
+  for (const line of census.jsxMissed)
+    console.log(`    nom non r\xE9solu, \xE0 v\xE9rifier : ${line}`);
+};
+var silentAxes = (report, d) => AXES.filter((axis) => axis !== "core" && d.configured.has(axis) && (report.counters[axis] ?? 0) === 0);
+var diagnosticsOf = (report, blind, silent) => {
+  const { census } = report;
+  return [
+    ...blind ? [
+      {
+        severity: "error",
+        message: `aucun enregistrement trouv\xE9 alors que ${report.factoryFiles} fichier(s) d\xE9clarent un navigateur \u2014 ` + `le dialecte ne correspond pas \xE0 ce projet`
+      }
+    ] : [],
+    ...census.callsSeen > 0 && census.callsResolved < census.callsSeen ? [
+      {
+        severity: "info",
+        message: `${census.callsSeen - census.callsResolved} appel(s) \`navigate\` sur ${census.callsSeen} sans ar\xEAte ` + `(${census.unknown.length > 0 ? `dont des cibles hors registre, ex. ${census.unknown[0]}` : "cibles calcul\xE9es"})`
+      }
+    ] : [],
+    ...silent.length > 0 ? [
+      {
+        severity: "warning",
+        message: `axe(s) de dialecte sans aucune correspondance : ${silent.join(", ")} \u2014 graphe probablement incomplet`
+      }
+    ] : [],
+    ...report.duplicates.length ? [
+      {
+        severity: "info",
+        message: `${report.duplicates.length} enregistrement(s) en double, premier retenu : ${report.duplicates.slice(0, 5).join(", ")}`
+      }
+    ] : [],
+    ...report.unlinked.length ? [
+      {
+        severity: "warning",
+        message: `${report.unlinked.length} screen(s) with no component: ${report.unlinked.slice(0, 5).join(", ")}`
+      }
+    ] : [],
+    ...report.multi.length ? [
+      {
+        severity: "info",
+        message: `${report.multi.length} route(s) registered more than once: ${report.multi.join(", ")}`
+      }
+    ] : [],
+    ...report.ambiguous.length ? [
+      {
+        severity: "warning",
+        message: `${report.ambiguous.length} nom(s) de composant ambigu(s) dans un fichier de navigateur : ${report.ambiguous.slice(0, 3).join(", ")}`
+      }
+    ] : [],
+    ...report.orphanCalls ? [
+      {
+        severity: "info",
+        message: `${report.orphanCalls} navigation call site(s) reachable from no screen`
+      }
+    ] : []
+  ];
+};
+var createReactNavigationContributor = (d) => ({
+  id: "react-navigation",
+  region: regionNavigation,
+  source: "sourced",
+  async produce(ctx) {
+    const [symbols] = await ctx.db.query`
+			MATCH (s:Symbol) WHERE s.workspace = ${ctx.workspace} RETURN count(*) AS n`;
+    if ((symbols?.n ?? 0) === 0) {
+      return {
+        status: "error",
+        diagnostics: [
+          {
+            severity: "error",
+            message: `no Symbol in workspace "${ctx.workspace}" \u2014 put this contributor after the code indexer`
+          }
+        ]
+      };
+    }
+    console.time("[react-navigation] extraction");
+    const model = await collect({
+      source: ctx.source,
+      projectRoot: ctx.root,
+      graph: cypherReader(ctx.db, ctx.workspace),
+      workspace: ctx.workspace
+    }, d);
+    console.timeEnd("[react-navigation] extraction");
+    const { report } = model;
+    logReport(report);
+    const blind = model.screens.length === 0 && report.factoryFiles > 0;
+    if (blind)
+      console.log(`[react-navigation] AUCUN enregistrement, alors que ${report.factoryFiles} fichier(s) ` + `d\xE9clarent un navigateur \u2014 le dialecte ne correspond pas \xE0 ce projet`);
+    console.log(`[react-navigation] ${model.routes.length} routes / ${model.screens.length} screens / ` + `${report.rendered} rendered / ${report.mounts.length} mounts / ${report.gates} gates / ` + `${report.callSites} call sites -> ${model.edges.length} NAVIGATES_TO edges ` + `(${report.borrowed} sites emprunt\xE9s retir\xE9s)`);
+    const silent = silentAxes(report, d);
+    return {
+      status: blind || silent.length > 0 ? "partial" : "ok",
+      diagnostics: diagnosticsOf(report, blind, silent),
+      payload: toPayload(model)
+    };
+  }
+});
+var reactNavigationContributor = (dialect = {}) => {
+  const d = resolveDialect(dialect);
+  return createReactNavigationContributor(d);
+};
+export {
+  reactNavigationContributor
+};