@cavuno/board 1.40.0 → 1.42.0

package/dist/route-contract.js

@@ -0,0 +1,1131 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/route-contract/index.ts
+var route_contract_exports = {};
+__export(route_contract_exports, {
+  ALL_ROLES: () => ALL_ROLES,
+  CANONICAL_MANIFEST: () => CANONICAL_MANIFEST,
+  REQUIRED_ROLES: () => REQUIRED_ROLES,
+  ROLE_INDEX_PATHS: () => ROLE_INDEX_PATHS,
+  ROLE_PARAM_REGISTRY: () => ROLE_PARAM_REGISTRY,
+  checkRoleTemplate: () => checkRoleTemplate,
+  classifyRoutes: () => classifyRoutes,
+  compileManifest: () => compileManifest,
+  compileManifestFromTree: () => compileManifestFromTree,
+  createBoardLinkResolver: () => createBoardLinkResolver,
+  deriveRoutes: () => deriveRoutes,
+  detectFramework: () => detectFramework,
+  enumerateRouteEntries: () => enumerateRouteEntries,
+  extractCavunoPageMarker: () => extractCavunoPageMarker,
+  extractParamNames: () => extractParamNames,
+  getReactRouterCandidatePaths: () => getReactRouterCandidatePaths,
+  isRouteRole: () => isRouteRole,
+  matchPathAgainstHistory: () => matchPathAgainstHistory,
+  matchPathToTemplate: () => matchPathToTemplate,
+  parseAstroRoutes: () => parseAstroRoutes,
+  parseNextRoutes: () => parseNextRoutes,
+  parseNuxtRoutes: () => parseNuxtRoutes,
+  parseReactRouterRoutes: () => parseReactRouterRoutes,
+  parseSvelteKitRoutes: () => parseSvelteKitRoutes,
+  parseTanStackRoutes: () => parseTanStackRoutes,
+  sameParamSet: () => sameParamSet,
+  validateManifest: () => validateManifest
+});
+module.exports = __toCommonJS(route_contract_exports);
+
+// src/paths/index.ts
+function jobDetailPath(companySlug, jobSlug) {
+  return `/companies/${companySlug}/jobs/${jobSlug}`;
+}
+function jobsCategoryPath(categorySlug) {
+  return `/jobs/${categorySlug}`;
+}
+function jobsSkillPath(skillSlug) {
+  return `/jobs/skills/${skillSlug}`;
+}
+function jobsLocationPath(placeSlug) {
+  return `/jobs/locations/${placeSlug}`;
+}
+function companyPath(companySlug) {
+  return `/companies/${companySlug}`;
+}
+function companyMarketPath(marketSlug) {
+  return `/companies/markets/${marketSlug}`;
+}
+function companySalaryPath(companySlug) {
+  return `/companies/${companySlug}/salaries`;
+}
+function salaryTitlePath(titleSlug) {
+  return `/salaries/titles/${titleSlug}`;
+}
+function salarySkillPath(skillSlug) {
+  return `/salaries/skills/${skillSlug}`;
+}
+function salaryLocationPath(placeSlug) {
+  return `/salaries/locations/${placeSlug}`;
+}
+function blogPostPath(postSlug) {
+  return `/blog/${postSlug}`;
+}
+function blogTagPath(tagSlug) {
+  return `/blog/tag/${tagSlug}`;
+}
+function blogAuthorPath(authorSlug) {
+  return `/blog/author/${authorSlug}`;
+}
+var BOARD_PATHS = {
+  home: "/",
+  jobs: "/jobs",
+  companies: "/companies",
+  salaries: "/salaries",
+  salaryCompanies: "/salaries/companies",
+  salaryTitles: "/salaries/titles",
+  salarySkills: "/salaries/skills",
+  salaryLocations: "/salaries/locations",
+  blog: "/blog",
+  about: "/about",
+  privacyPolicy: "/privacy-policy",
+  termsOfService: "/terms-of-service",
+  cookiePolicy: "/cookie-policy",
+  impressum: "/impressum",
+  talent: "/talent",
+  employers: "/employers",
+  /**
+   * Alert-email surfaces (ADR-0090 D1/D4). Promoted out of raw literals in
+   * the job-alerts composer so /go indirection and email composition share
+   * one definition.
+   */
+  alertsManage: "/alerts/manage",
+  alertsConfirm: "/alerts/confirm"
+};
+
+// src/route-contract/roles.ts
+var ROLE_PARAM_REGISTRY = {
+  jobDetail: ["companySlug", "jobSlug"],
+  jobsCategory: ["categorySlug"],
+  jobsSkill: ["skillSlug"],
+  jobsLocation: ["placeSlug"],
+  company: ["companySlug"],
+  companyMarket: ["marketSlug"],
+  companySalary: ["companySlug"],
+  salaryTitle: ["titleSlug"],
+  salarySkill: ["skillSlug"],
+  salaryLocation: ["placeSlug"],
+  blogPost: ["postSlug"],
+  blogTag: ["tagSlug"],
+  blogAuthor: ["authorSlug"],
+  home: [],
+  jobs: [],
+  companies: [],
+  salaries: [],
+  salaryCompanies: [],
+  salaryTitles: [],
+  salarySkills: [],
+  salaryLocations: [],
+  blog: [],
+  about: [],
+  privacyPolicy: [],
+  termsOfService: [],
+  cookiePolicy: [],
+  impressum: [],
+  talent: [],
+  employers: [],
+  alertsManage: [],
+  alertsConfirm: []
+};
+var REQUIRED_ROLES = [
+  "jobDetail",
+  "alertsManage",
+  "alertsConfirm"
+];
+var ALL_ROLES = Object.keys(
+  ROLE_PARAM_REGISTRY
+);
+var ROLE_SET = new Set(ALL_ROLES);
+function isRouteRole(value) {
+  return ROLE_SET.has(value);
+}
+var CANONICAL_MANIFEST = {
+  version: 1,
+  roles: {
+    jobDetail: jobDetailPath(":companySlug", ":jobSlug"),
+    jobsCategory: jobsCategoryPath(":categorySlug"),
+    jobsSkill: jobsSkillPath(":skillSlug"),
+    jobsLocation: jobsLocationPath(":placeSlug"),
+    company: companyPath(":companySlug"),
+    companyMarket: companyMarketPath(":marketSlug"),
+    companySalary: companySalaryPath(":companySlug"),
+    salaryTitle: salaryTitlePath(":titleSlug"),
+    salarySkill: salarySkillPath(":skillSlug"),
+    salaryLocation: salaryLocationPath(":placeSlug"),
+    blogPost: blogPostPath(":postSlug"),
+    blogTag: blogTagPath(":tagSlug"),
+    blogAuthor: blogAuthorPath(":authorSlug"),
+    home: BOARD_PATHS.home,
+    jobs: BOARD_PATHS.jobs,
+    companies: BOARD_PATHS.companies,
+    salaries: BOARD_PATHS.salaries,
+    salaryCompanies: BOARD_PATHS.salaryCompanies,
+    salaryTitles: BOARD_PATHS.salaryTitles,
+    salarySkills: BOARD_PATHS.salarySkills,
+    salaryLocations: BOARD_PATHS.salaryLocations,
+    blog: BOARD_PATHS.blog,
+    about: BOARD_PATHS.about,
+    privacyPolicy: BOARD_PATHS.privacyPolicy,
+    termsOfService: BOARD_PATHS.termsOfService,
+    cookiePolicy: BOARD_PATHS.cookiePolicy,
+    impressum: BOARD_PATHS.impressum,
+    talent: BOARD_PATHS.talent,
+    employers: BOARD_PATHS.employers,
+    alertsManage: "/alerts/manage",
+    alertsConfirm: "/alerts/confirm"
+  }
+};
+
+// src/route-contract/params.ts
+function extractParamNames(template) {
+  const names = [];
+  const re = /:([A-Za-z_][A-Za-z0-9_]*)/g;
+  let match;
+  while ((match = re.exec(template)) !== null) {
+    const name = match[1];
+    if (name !== void 0) names.push(name);
+  }
+  return names;
+}
+function sameParamSet(a, b) {
+  if (a.length !== b.length) return false;
+  const sortedA = [...a].sort();
+  const sortedB = [...b].sort();
+  for (let i = 0; i < sortedA.length; i++) {
+    if (sortedA[i] !== sortedB[i]) return false;
+  }
+  return true;
+}
+function paramSetKey(params) {
+  return [...params].sort().join("\0");
+}
+
+// src/route-contract/classify.ts
+var SHARED_SIGNATURE_COUNTS = (() => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const role of ALL_ROLES) {
+    const params = ROLE_PARAM_REGISTRY[role];
+    if (params.length === 0) continue;
+    const key = paramSetKey(params);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+})();
+function isSignatureCandidate(route, role) {
+  const registry = ROLE_PARAM_REGISTRY[role];
+  const routeParams = extractParamNames(route.template);
+  if (registry.length === 0) {
+    return route.template === CANONICAL_MANIFEST.roles[role];
+  }
+  if (!sameParamSet(routeParams, registry)) return false;
+  const shareCount = SHARED_SIGNATURE_COUNTS.get(paramSetKey(registry)) ?? 0;
+  if (shareCount > 1) {
+    return route.template === CANONICAL_MANIFEST.roles[role];
+  }
+  return true;
+}
+function classifyRoutes(routes, markers) {
+  const assignments = {};
+  const ambiguities = [];
+  const claimed = /* @__PURE__ */ new Set();
+  if (markers && markers.size > 0) {
+    const claimsByRole = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      if (route.sourcePath === void 0) continue;
+      const role = markers.get(route.sourcePath);
+      if (role === void 0) continue;
+      const list = claimsByRole.get(role);
+      if (list) list.push(route);
+      else claimsByRole.set(role, [route]);
+    }
+    for (const [role, candidates] of claimsByRole) {
+      for (const c of candidates) claimed.add(c);
+      if (candidates.length === 1) {
+        assignments[role] = candidates[0];
+      } else {
+        ambiguities.push({ role, candidates: [...candidates] });
+      }
+    }
+  }
+  const pool = routes.filter((r) => !claimed.has(r));
+  for (const role of ALL_ROLES) {
+    if (assignments[role] !== void 0) continue;
+    if (ambiguities.some((a) => a.role === role)) continue;
+    const candidates = pool.filter((r) => isSignatureCandidate(r, role));
+    if (candidates.length === 0) continue;
+    if (candidates.length === 1) {
+      const only = candidates[0];
+      if (claimed.has(only)) {
+        continue;
+      }
+      assignments[role] = only;
+      claimed.add(only);
+      continue;
+    }
+    ambiguities.push({ role, candidates: [...candidates] });
+  }
+  const missingRequired = REQUIRED_ROLES.filter(
+    (role) => assignments[role] === void 0
+  );
+  return { assignments, ambiguities, missingRequired };
+}
+
+// src/route-contract/validate.ts
+var TEMPLATE_CHARSET_RE = /^[A-Za-z0-9/_.:-]+$/;
+function checkRoleTemplate(role, template) {
+  const errors = [];
+  if (typeof template !== "string" || template.length === 0) {
+    errors.push({
+      code: "invalid_template",
+      message: `role '${role}' template must be a non-empty string`,
+      role
+    });
+    return errors;
+  }
+  if (!template.startsWith("/")) {
+    errors.push({
+      code: "invalid_template",
+      message: `role '${role}' template must start with '/', got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  if (/\s/.test(template)) {
+    errors.push({
+      code: "invalid_template",
+      message: `role '${role}' template must not contain whitespace, got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  if (template.includes("?") || template.includes("#")) {
+    errors.push({
+      code: "template_query_or_fragment",
+      message: `role '${role}' template must not contain '?' or '#', got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  if (template.startsWith("//") || template.includes("//")) {
+    errors.push({
+      code: "template_double_slash",
+      message: `role '${role}' template must not contain '//', got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  for (const seg of template.split("/")) {
+    if (seg === "." || seg === "..") {
+      errors.push({
+        code: "template_dot_segment",
+        message: `role '${role}' template must not contain '.' or '..' segments, got ${JSON.stringify(template)}`,
+        role
+      });
+      return errors;
+    }
+  }
+  if (!TEMPLATE_CHARSET_RE.test(template)) {
+    errors.push({
+      code: "template_illegal_charset",
+      message: `role '${role}' template contains illegal characters, got ${JSON.stringify(template)}`,
+      role
+    });
+    return errors;
+  }
+  const registry = ROLE_PARAM_REGISTRY[role];
+  const tokens = extractParamNames(template);
+  if (registry.length === 0) {
+    if (tokens.length > 0) {
+      errors.push({
+        code: "static_has_params",
+        message: `static role '${role}' template must not contain ':' tokens, got ${template}`,
+        role,
+        token: tokens[0]
+      });
+    }
+  } else {
+    const registrySet = new Set(registry);
+    for (const token of tokens) {
+      if (!registrySet.has(token)) {
+        errors.push({
+          code: "unregistered_param",
+          message: `role '${role}' template references unregistered param ':${token}'`,
+          role,
+          token
+        });
+      }
+    }
+    const retained = tokens.filter((t) => registrySet.has(t));
+    if (retained.length === 0) {
+      errors.push({
+        code: "missing_entity_param",
+        message: `role '${role}' template must contain at least one registry param (${registry.join(", ")})`,
+        role
+      });
+    }
+  }
+  return errors;
+}
+function validateManifest(value) {
+  const errors = [];
+  if (value === null || typeof value !== "object") {
+    return {
+      ok: false,
+      errors: [
+        {
+          code: "invalid_shape",
+          message: "manifest must be an object"
+        }
+      ]
+    };
+  }
+  const record = value;
+  if (record.version !== 1) {
+    errors.push({
+      code: "invalid_version",
+      message: `manifest version must be 1, got ${JSON.stringify(record.version)}`
+    });
+  }
+  if (record.roles === null || typeof record.roles !== "object" || Array.isArray(record.roles)) {
+    errors.push({
+      code: "invalid_shape",
+      message: "manifest.roles must be an object"
+    });
+    return { ok: false, errors };
+  }
+  const rolesIn = record.roles;
+  const rolesOut = {};
+  for (const [key, template] of Object.entries(rolesIn)) {
+    if (!isRouteRole(key)) {
+      errors.push({
+        code: "unknown_role",
+        message: `unknown role '${key}'`,
+        role: key
+      });
+      continue;
+    }
+    if (typeof template !== "string") {
+      errors.push({
+        code: "invalid_template",
+        message: `role '${key}' template must be a non-empty string`,
+        role: key
+      });
+      continue;
+    }
+    const role = key;
+    const roleErrors = checkRoleTemplate(role, template);
+    if (roleErrors.length > 0) {
+      errors.push(...roleErrors);
+      continue;
+    }
+    rolesOut[role] = template;
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    manifest: { version: 1, roles: rolesOut }
+  };
+}
+
+// src/route-contract/compile.ts
+var REQUIRED_SET = new Set(REQUIRED_ROLES);
+function compileManifest(routes, markers) {
+  const { assignments, ambiguities, missingRequired } = classifyRoutes(
+    routes,
+    markers
+  );
+  const roles = {};
+  const warnings = [];
+  const blocking = new Set(missingRequired);
+  for (const role of ALL_ROLES) {
+    const entry = assignments[role];
+    if (entry === void 0) continue;
+    const templateErrors = checkRoleTemplate(role, entry.template);
+    if (templateErrors.length > 0) {
+      const exact = templateErrors.map((e) => e.message).join("; ");
+      warnings.push(
+        `role '${role}' template rejected: ${exact} \u2014 add export const cavunoPage = '${role}' on the correct page or fix the template`
+      );
+      if (REQUIRED_SET.has(role)) {
+        blocking.add(role);
+      }
+      continue;
+    }
+    roles[role] = entry.template;
+  }
+  for (const amb of ambiguities) {
+    const kind = REQUIRED_SET.has(amb.role) ? "required" : "optional";
+    warnings.push(
+      `${kind} role '${amb.role}' is ambiguous \u2014 add export const cavunoPage = '${amb.role}' to disambiguate`
+    );
+  }
+  for (const role of ALL_ROLES) {
+    if (REQUIRED_SET.has(role)) continue;
+    if (roles[role] !== void 0) continue;
+    if (assignments[role] !== void 0) continue;
+    if (ambiguities.some((a) => a.role === role)) continue;
+    warnings.push(`optional role '${role}' is unassigned`);
+  }
+  return {
+    manifest: { version: 1, roles },
+    blockingMissing: REQUIRED_ROLES.filter((r) => blocking.has(r)),
+    warnings,
+    ambiguities
+  };
+}
+
+// src/route-contract/enumerate/collect.ts
+function collectRoutes(routes) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const derived of routes) {
+    if (derived === null) continue;
+    const existing = byPath.get(derived.path);
+    if (existing === void 0) {
+      byPath.set(derived.path, {
+        navigable: derived.navigable,
+        sourcePath: derived.sourcePath
+      });
+    } else {
+      byPath.set(derived.path, {
+        navigable: existing.navigable || derived.navigable,
+        sourcePath: existing.sourcePath ?? derived.sourcePath
+      });
+    }
+  }
+  return [...byPath.entries()].map(([path, meta]) => {
+    const route = { path, navigable: meta.navigable };
+    if (meta.sourcePath !== void 0) {
+      route.sourcePath = meta.sourcePath;
+    }
+    return route;
+  }).sort((a, b) => {
+    if (a.path === "/") return -1;
+    if (b.path === "/") return 1;
+    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+  });
+}
+function normalizeListingPath(filePath) {
+  return filePath.replace(/^\.\//, "");
+}
+
+// src/route-contract/enumerate/astro.ts
+var PAGE_EXT = /\.(astro|md|mdx|html)$/i;
+function parseAstroRoutes(paths) {
+  const normalized = paths.map(normalizeListingPath);
+  const preferSrc = normalized.some((p) => p.startsWith("src/pages/"));
+  return collectRoutes(
+    normalized.map((p) => pathToRoute(p, preferSrc ? "src/pages/" : null))
+  );
+}
+function pathToRoute(normalized, forcedRoot) {
+  const root = pagesRoot(normalized, forcedRoot);
+  if (root === null) return null;
+  if (!PAGE_EXT.test(normalized)) return null;
+  const afterRoot = normalized.slice(root.length);
+  if (afterRoot === "api" || afterRoot.startsWith("api/")) return null;
+  const rel = afterRoot.replace(PAGE_EXT, "");
+  if (rel.length === 0) return null;
+  const segments = rel.split("/").filter((s) => s.length > 0);
+  const urlSegments = [];
+  let hasDynamic = false;
+  for (const seg of segments) {
+    if (seg.startsWith("_")) return null;
+    if (seg === "index") continue;
+    if (seg.startsWith("[") && seg.endsWith("]")) {
+      hasDynamic = true;
+      let inner = seg.slice(1, -1);
+      if (inner.startsWith("[") && inner.endsWith("]")) {
+        inner = inner.slice(1, -1);
+      }
+      if (inner.startsWith("...")) {
+        urlSegments.push("*");
+      } else {
+        urlSegments.push(`:${inner}`);
+      }
+      continue;
+    }
+    urlSegments.push(seg);
+  }
+  const path = urlSegments.length === 0 ? "/" : `/${urlSegments.join("/")}`;
+  return { path, navigable: !hasDynamic, sourcePath: normalized };
+}
+function pagesRoot(normalized, forcedRoot) {
+  if (forcedRoot !== null) {
+    return normalized.startsWith(forcedRoot) ? forcedRoot : null;
+  }
+  if (normalized.startsWith("src/pages/")) return "src/pages/";
+  if (normalized.startsWith("pages/")) return "pages/";
+  return null;
+}
+
+// src/route-contract/enumerate/react-router.ts
+function getReactRouterCandidatePaths(paths) {
+  const candidates = [];
+  for (const raw of paths) {
+    const p = normalizeListingPath(raw);
+    const base = p.split("/").pop() ?? p;
+    const lower = base.toLowerCase();
+    if (/^app\.(tsx|ts|jsx|js)$/i.test(base)) {
+      candidates.push(p);
+      continue;
+    }
+    if (/^router\.(tsx|ts|jsx|js)$/i.test(base)) {
+      candidates.push(p);
+      continue;
+    }
+    if (lower.includes("routes") && /\.(tsx|ts|jsx|js)$/i.test(base) && !base.endsWith(".d.ts")) {
+      candidates.push(p);
+    }
+  }
+  return candidates.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function parseReactRouterRoutes(contents) {
+  const found = [];
+  for (const source of contents) {
+    const jsxRe = /\bpath\s*=\s*(?:["']([^"']+)["']|\{\s*["']([^"']+)["']\s*\})/g;
+    let m;
+    while ((m = jsxRe.exec(source)) !== null) {
+      const raw = m[1] ?? m[2];
+      if (raw === void 0) continue;
+      const route = toDerived(raw);
+      if (route) found.push(route);
+    }
+    const objRe = /\bpath\s*:\s*["']([^"']+)["']/g;
+    while ((m = objRe.exec(source)) !== null) {
+      const raw = m[1];
+      if (raw === void 0) continue;
+      const route = toDerived(raw);
+      if (route) found.push(route);
+    }
+  }
+  return collectRoutes(found);
+}
+function toDerived(rawPath) {
+  const trimmed = rawPath.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed === "*" || trimmed === "/*") return null;
+  const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  const path = withSlash.length > 1 && withSlash.endsWith("/") ? withSlash.slice(0, -1) : withSlash;
+  const hasDynamic = path.includes(":") || path.includes("*") || path.includes("(");
+  return { path, navigable: !hasDynamic };
+}
+
+// src/route-contract/enumerate/detect.ts
+function detectFramework(paths) {
+  const normalized = paths.map(normalizeListingPath);
+  if (hasExplicitTanStackMarkers(normalized)) return "tanstack";
+  if (isNext(normalized)) return "next";
+  if (isAstro(normalized)) return "astro";
+  if (isSvelteKit(normalized)) return "sveltekit";
+  if (isNuxt(normalized)) return "nuxt";
+  if (hasMarkerlessTanStackRoutes(normalized)) return "tanstack";
+  if (getReactRouterCandidatePaths(normalized).length > 0) {
+    return "react-router";
+  }
+  return null;
+}
+function hasExplicitTanStackMarkers(paths) {
+  return paths.some(
+    (p) => p === "src/routeTree.gen.ts" || p === "src/routeTree.gen.js" || /^src\/routes\/__root\.[^/]+$/i.test(p)
+  );
+}
+function hasMarkerlessTanStackRoutes(paths) {
+  return paths.some((p) => {
+    if (!/^src\/routes\/.+\.(tsx|jsx)$/i.test(p)) return false;
+    if (p.endsWith(".d.ts")) return false;
+    const base = p.split("/").pop() ?? "";
+    if (base.startsWith("+")) return false;
+    return true;
+  });
+}
+function isNext(paths) {
+  const hasConfig = paths.some((p) => /^next\.config\.[^/]+$/i.test(p));
+  if (!hasConfig) return false;
+  return paths.some(
+    (p) => (
+      // App router page files
+      /^(src\/)?app\/.*\/page\.(tsx|ts|jsx|js)$/i.test(p) || /^(src\/)?app\/page\.(tsx|ts|jsx|js)$/i.test(p) || // Pages router (exclude special _app/_document/_error and api)
+      /^(src\/)?pages\/.+\.(tsx|ts|jsx|js)$/i.test(p) && !/\/api\//i.test(p) && !/(?:^|\/)_(?:app|document|error)\./i.test(p)
+    )
+  );
+}
+function isAstro(paths) {
+  return paths.some((p) => /^astro\.config\.[^/]+$/i.test(p));
+}
+function isSvelteKit(paths) {
+  const hasConfig = paths.some((p) => /^svelte\.config\.[^/]+$/i.test(p));
+  if (!hasConfig) return false;
+  return paths.some((p) => /(?:^|\/)\+page(?:@[^/]*)?\.[^/]+$/i.test(p));
+}
+function isNuxt(paths) {
+  return paths.some((p) => /^nuxt\.config\.[^/]+$/i.test(p));
+}
+
+// src/route-contract/enumerate/next.ts
+var APP_PAGE_FILE = /(?:^|\/)page\.(tsx|ts|jsx|js)$/i;
+var PAGES_EXT = /\.(tsx|ts|jsx|js)$/i;
+var PAGES_SPECIAL = /(?:^|\/)_(?:app|document|error)\.[^/]+$/i;
+function parseNextRoutes(paths) {
+  return collectRoutes([
+    ...paths.map(pathToAppRoute),
+    ...paths.map(pathToPagesRoute)
+  ]);
+}
+function pathToAppRoute(filePath) {
+  const normalized = normalizeListingPath(filePath);
+  const root = appRoot(normalized);
+  if (root === null) return null;
+  if (!APP_PAGE_FILE.test(normalized)) return null;
+  const afterRoot = normalized.slice(root.length);
+  const rel = afterRoot.replace(/(?:^|\/)page\.(tsx|ts|jsx|js)$/i, "");
+  const segments = rel.length === 0 ? [] : rel.split("/");
+  const urlSegments = [];
+  let hasDynamic = false;
+  for (const seg of segments) {
+    if (seg.length === 0) continue;
+    if (seg.startsWith("_")) return null;
+    if (seg.startsWith("@")) continue;
+    if (isInterceptingSegment(seg)) return null;
+    if (seg.startsWith("(") && seg.endsWith(")")) continue;
+    if (seg.startsWith("[") && seg.endsWith("]")) {
+      hasDynamic = true;
+      let inner = seg.slice(1, -1);
+      if (inner.startsWith("[") && inner.endsWith("]")) {
+        inner = inner.slice(1, -1);
+      }
+      if (inner.startsWith("...")) {
+        urlSegments.push("*");
+      } else {
+        urlSegments.push(`:${inner}`);
+      }
+      continue;
+    }
+    urlSegments.push(seg);
+  }
+  const path = urlSegments.length === 0 ? "/" : `/${urlSegments.join("/")}`;
+  if (path === "/api" || path.startsWith("/api/")) return null;
+  return { path, navigable: !hasDynamic, sourcePath: normalized };
+}
+function isInterceptingSegment(seg) {
+  return /^\(\.{1,}\)(\(\.{1,}\))*/.test(seg);
+}
+function appRoot(normalized) {
+  if (normalized.startsWith("src/app/")) return "src/app/";
+  if (normalized.startsWith("app/")) return "app/";
+  return null;
+}
+function pathToPagesRoute(filePath) {
+  const normalized = normalizeListingPath(filePath);
+  const root = pagesRoot2(normalized);
+  if (root === null) return null;
+  if (!PAGES_EXT.test(normalized)) return null;
+  if (normalized.endsWith(".d.ts")) return null;
+  const afterRoot = normalized.slice(root.length);
+  if (afterRoot === "api" || afterRoot.startsWith("api/")) return null;
+  if (PAGES_SPECIAL.test(afterRoot)) return null;
+  const rel = afterRoot.replace(PAGES_EXT, "");
+  if (rel.length === 0) return null;
+  const segments = rel.split("/").filter((s) => s.length > 0);
+  const urlSegments = [];
+  let hasDynamic = false;
+  for (const seg of segments) {
+    if (seg.startsWith("_")) return null;
+    if (seg === "index") continue;
+    if (seg.startsWith("[") && seg.endsWith("]")) {
+      hasDynamic = true;
+      let inner = seg.slice(1, -1);
+      if (inner.startsWith("[") && inner.endsWith("]")) {
+        inner = inner.slice(1, -1);
+      }
+      if (inner.startsWith("...")) {
+        urlSegments.push("*");
+      } else {
+        urlSegments.push(`:${inner}`);
+      }
+      continue;
+    }
+    urlSegments.push(seg);
+  }
+  const path = urlSegments.length === 0 ? "/" : `/${urlSegments.join("/")}`;
+  return { path, navigable: !hasDynamic, sourcePath: normalized };
+}
+function pagesRoot2(normalized) {
+  if (normalized.startsWith("src/pages/")) return "src/pages/";
+  if (normalized.startsWith("pages/")) return "pages/";
+  return null;
+}
+
+// src/route-contract/enumerate/nuxt.ts
+var PAGE_EXT2 = /\.(vue|tsx|ts|jsx|js)$/i;
+function parseNuxtRoutes(paths) {
+  return collectRoutes(paths.map(pathToRoute2));
+}
+function pathToRoute2(filePath) {
+  const normalized = normalizeListingPath(filePath);
+  const root = pagesRoot3(normalized);
+  if (root === null) return null;
+  if (!PAGE_EXT2.test(normalized)) return null;
+  if (normalized.endsWith(".d.ts")) return null;
+  const afterRoot = normalized.slice(root.length);
+  const rel = afterRoot.replace(PAGE_EXT2, "");
+  if (rel.length === 0) return null;
+  const segments = rel.split("/").filter((s) => s.length > 0);
+  const urlSegments = [];
+  let hasDynamic = false;
+  for (const seg of segments) {
+    if (seg.startsWith("_")) return null;
+    if (seg === "index") continue;
+    if (seg.startsWith("[") && seg.endsWith("]")) {
+      hasDynamic = true;
+      let inner = seg.slice(1, -1);
+      if (inner.startsWith("[") && inner.endsWith("]")) {
+        inner = inner.slice(1, -1);
+      }
+      if (inner.startsWith("...")) {
+        urlSegments.push("*");
+      } else {
+        urlSegments.push(`:${inner}`);
+      }
+      continue;
+    }
+    urlSegments.push(seg);
+  }
+  const path = urlSegments.length === 0 ? "/" : `/${urlSegments.join("/")}`;
+  return { path, navigable: !hasDynamic, sourcePath: normalized };
+}
+function pagesRoot3(normalized) {
+  if (normalized.startsWith("src/pages/")) return "src/pages/";
+  if (normalized.startsWith("pages/")) return "pages/";
+  return null;
+}
+
+// src/route-contract/enumerate/sveltekit.ts
+var ROUTES_PREFIX = "src/routes/";
+var ROOT_PAGE = /^\+page(?:@[^/]*)?\.svelte$/i;
+var NESTED_PAGE = /\/\+page(?:@[^/]*)?\.svelte$/i;
+function parseSvelteKitRoutes(paths) {
+  return collectRoutes(paths.map(pathToRoute3));
+}
+function pathToRoute3(filePath) {
+  const normalized = normalizeListingPath(filePath);
+  if (!normalized.startsWith(ROUTES_PREFIX)) return null;
+  const afterRoot = normalized.slice(ROUTES_PREFIX.length);
+  let rel;
+  if (ROOT_PAGE.test(afterRoot)) {
+    rel = "";
+  } else if (NESTED_PAGE.test(afterRoot)) {
+    rel = afterRoot.replace(NESTED_PAGE, "");
+  } else {
+    return null;
+  }
+  const segments = rel.length === 0 ? [] : rel.split("/");
+  const urlSegments = [];
+  let hasDynamic = false;
+  for (const seg of segments) {
+    if (seg.length === 0) continue;
+    if (seg.startsWith("(") && seg.endsWith(")")) continue;
+    if (seg.startsWith("_")) return null;
+    if (seg.startsWith("[") && seg.endsWith("]")) {
+      hasDynamic = true;
+      let inner = seg.slice(1, -1);
+      if (inner.startsWith("[") && inner.endsWith("]")) {
+        inner = inner.slice(1, -1);
+      }
+      if (inner.startsWith("...")) {
+        urlSegments.push("*");
+      } else {
+        urlSegments.push(`:${inner}`);
+      }
+      continue;
+    }
+    urlSegments.push(seg);
+  }
+  const path = urlSegments.length === 0 ? "/" : `/${urlSegments.join("/")}`;
+  return { path, navigable: !hasDynamic, sourcePath: normalized };
+}
+
+// src/route-contract/enumerate/tanstack.ts
+var ROUTES_PREFIX2 = "src/routes/";
+var PAGE_EXT3 = /\.(tsx|jsx)$/i;
+function parseTanStackRoutes(paths) {
+  return collectRoutes(paths.map(pathToRoute4));
+}
+function pathToRoute4(filePath) {
+  const normalized = normalizeListingPath(filePath);
+  if (!normalized.startsWith(ROUTES_PREFIX2)) return null;
+  if (normalized.endsWith(".d.ts")) return null;
+  if (!PAGE_EXT3.test(normalized)) return null;
+  const rel = normalized.slice(ROUTES_PREFIX2.length).replace(PAGE_EXT3, "");
+  if (rel.length === 0) return null;
+  if (rel === "route" || rel.endsWith("/route") || rel.endsWith(".route")) {
+    return null;
+  }
+  if (rel.includes("[") || rel.includes("{")) return null;
+  const rawSegments = rel.split("/").flatMap((part) => part.split(".")).filter((seg) => seg.length > 0);
+  const urlSegments = [];
+  let hasDynamic = false;
+  let hadIndex = false;
+  let hadConcrete = false;
+  for (const seg of rawSegments) {
+    if (seg.startsWith("-")) return null;
+    if (seg === "__root") return null;
+    if (seg.startsWith("_")) continue;
+    if (seg === "index") {
+      hadIndex = true;
+      continue;
+    }
+    if (seg.startsWith("$")) {
+      hasDynamic = true;
+      hadConcrete = true;
+      const param = seg.slice(1);
+      urlSegments.push(param.length > 0 ? `:${param}` : "*");
+      continue;
+    }
+    hadConcrete = true;
+    urlSegments.push(seg);
+  }
+  if (urlSegments.length === 0 && !hadIndex && !hadConcrete) {
+    return null;
+  }
+  const path = urlSegments.length === 0 ? "/" : `/${urlSegments.join("/")}`;
+  return { path, navigable: !hasDynamic, sourcePath: normalized };
+}
+
+// src/route-contract/enumerate/index.ts
+function enumerateDerived(paths) {
+  const framework = detectFramework(paths);
+  if (framework === null) return [];
+  switch (framework) {
+    case "tanstack":
+      return parseTanStackRoutes(paths);
+    case "next":
+      return parseNextRoutes(paths);
+    case "astro":
+      return parseAstroRoutes(paths);
+    case "sveltekit":
+      return parseSvelteKitRoutes(paths);
+    case "nuxt":
+      return parseNuxtRoutes(paths);
+    case "react-router":
+      return [];
+    default: {
+      const _exhaustive = framework;
+      return _exhaustive;
+    }
+  }
+}
+function deriveRoutes(paths) {
+  return enumerateDerived(paths).map(({ path, navigable }) => ({
+    path,
+    navigable
+  }));
+}
+function enumerateRouteEntries(paths) {
+  return enumerateDerived(paths).map(({ path, sourcePath }) => {
+    const entry = { template: path };
+    if (sourcePath !== void 0) entry.sourcePath = sourcePath;
+    return entry;
+  });
+}
+
+// src/route-contract/markers.ts
+function kebabToCamel(token) {
+  return token.replace(/-([a-zA-Z0-9])/g, (_, ch) => ch.toUpperCase());
+}
+function extractCavunoPageMarker(contents) {
+  const re = /export\s+const\s+cavunoPage\s*=\s*(['"])([A-Za-z_][A-Za-z0-9_-]*)\1\s*(?:as\s+const)?\s*;?/;
+  const match = re.exec(contents);
+  if (!match) return null;
+  const raw = match[2];
+  if (raw === void 0) return null;
+  if (isRouteRole(raw)) return raw;
+  const camel = kebabToCamel(raw);
+  if (isRouteRole(camel)) return camel;
+  return null;
+}
+
+// src/route-contract/compile-from-tree.ts
+function compileManifestFromTree(files) {
+  const paths = files.map((f) => f.path);
+  const routes = enumerateRouteEntries(paths);
+  const markers = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const role = extractCavunoPageMarker(file.contents);
+    if (role !== null) {
+      markers.set(file.path.replace(/^\.\//, ""), role);
+    }
+  }
+  return compileManifest(routes, markers.size > 0 ? markers : void 0);
+}
+
+// src/route-contract/resolve-links.ts
+var LAYER_ORDER = [
+  "declared",
+  "wellKnown",
+  "inferred"
+];
+var REQUIRED_SET2 = new Set(REQUIRED_ROLES);
+function trySubstitute(template, role, params) {
+  const registry = ROLE_PARAM_REGISTRY[role];
+  const registrySet = new Set(registry);
+  const tokens = extractParamNames(template);
+  for (const name of tokens) {
+    if (!registrySet.has(name)) {
+      return null;
+    }
+    if (params?.[name] === void 0) {
+      return null;
+    }
+  }
+  let path = template;
+  for (const name of tokens) {
+    path = path.split(`:${name}`).join(params[name]);
+  }
+  return path;
+}
+function forceSubstitute(template, params) {
+  return template.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (_m, name) => {
+    return params?.[name] ?? "";
+  });
+}
+function templateFor(manifest, role) {
+  const t = manifest.roles[role];
+  if (typeof t !== "string" || t.length === 0) return void 0;
+  return t;
+}
+function createBoardLinkResolver(layers) {
+  const bySource = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    if (!bySource.has(layer.source)) {
+      bySource.set(layer.source, layer);
+    }
+  }
+  return {
+    pathFor(role, params) {
+      let sawMissingParam = false;
+      for (const source of LAYER_ORDER) {
+        if (source === "inferred" && REQUIRED_SET2.has(role)) {
+          continue;
+        }
+        const layer = bySource.get(source);
+        if (!layer) continue;
+        const template = templateFor(layer.manifest, role);
+        if (template === void 0) continue;
+        const path2 = trySubstitute(template, role, params);
+        if (path2 !== null) {
+          return { path: path2, source };
+        }
+        sawMissingParam = true;
+      }
+      const canonicalTemplate = templateFor(CANONICAL_MANIFEST, role) ?? CANONICAL_MANIFEST.roles[role] ?? "/";
+      const path = trySubstitute(canonicalTemplate, role, params);
+      if (path !== null) {
+        return sawMissingParam ? { path, source: "canonical", fallback: "missing-param" } : { path, source: "canonical" };
+      }
+      return {
+        path: forceSubstitute(canonicalTemplate, params),
+        source: "canonical",
+        fallback: "missing-param"
+      };
+    }
+  };
+}
+
+// src/route-contract/match-history.ts
+var ROLE_INDEX_PATHS = {
+  jobDetail: BOARD_PATHS.jobs,
+  jobsCategory: BOARD_PATHS.jobs,
+  jobsSkill: BOARD_PATHS.jobs,
+  jobsLocation: BOARD_PATHS.jobs,
+  company: BOARD_PATHS.companies,
+  companyMarket: BOARD_PATHS.companies,
+  companySalary: BOARD_PATHS.companies,
+  salaryTitle: BOARD_PATHS.salaries,
+  salarySkill: BOARD_PATHS.salaries,
+  salaryLocation: BOARD_PATHS.salaries,
+  salaryCompanies: BOARD_PATHS.salaries,
+  salaryTitles: BOARD_PATHS.salaries,
+  salarySkills: BOARD_PATHS.salaries,
+  salaryLocations: BOARD_PATHS.salaries,
+  salaries: BOARD_PATHS.salaries,
+  blogPost: BOARD_PATHS.blog,
+  blogTag: BOARD_PATHS.blog,
+  blogAuthor: BOARD_PATHS.blog,
+  blog: BOARD_PATHS.blog,
+  home: BOARD_PATHS.home,
+  jobs: BOARD_PATHS.jobs,
+  companies: BOARD_PATHS.companies,
+  about: BOARD_PATHS.about,
+  privacyPolicy: BOARD_PATHS.privacyPolicy,
+  termsOfService: BOARD_PATHS.termsOfService,
+  cookiePolicy: BOARD_PATHS.cookiePolicy,
+  impressum: BOARD_PATHS.impressum,
+  talent: BOARD_PATHS.talent,
+  employers: BOARD_PATHS.employers,
+  alertsManage: BOARD_PATHS.home,
+  alertsConfirm: BOARD_PATHS.home
+};
+function splitSegments(path) {
+  const withoutLeading = path.startsWith("/") ? path.slice(1) : path;
+  const withoutTrailing = withoutLeading.length > 1 && withoutLeading.endsWith("/") ? withoutLeading.slice(0, -1) : withoutLeading;
+  if (withoutTrailing === "") return [];
+  return withoutTrailing.split("/");
+}
+function matchPathToTemplate(template, pathname) {
+  const templateSegs = splitSegments(template);
+  const pathSegs = splitSegments(pathname);
+  if (templateSegs.length !== pathSegs.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < templateSegs.length; i++) {
+    const tSeg = templateSegs[i];
+    const pSeg = pathSegs[i];
+    if (tSeg.startsWith(":") && tSeg.length > 1) {
+      if (pSeg.length === 0) return null;
+      if (pSeg.includes("/") || pSeg.includes("\\")) return null;
+      params[tSeg.slice(1)] = pSeg;
+      continue;
+    }
+    if (tSeg !== pSeg) return null;
+  }
+  return params;
+}
+function matchPathAgainstHistory(entries, pathname) {
+  for (const entry of entries) {
+    const params = matchPathToTemplate(entry.template, pathname);
+    if (params !== null) {
+      return {
+        role: entry.role,
+        template: entry.template,
+        params
+      };
+    }
+  }
+  return null;
+}