@cavuno/board 4.42.0 → 4.44.0

package/dist/doctor.js

@@ -68,6 +68,358 @@ function loadSkillCorpus(baseDir) {
   };
 }
 
+// src/paths/index.ts
+function encodePathSegment(segment) {
+  try {
+    return encodeURIComponent(decodeURIComponent(segment)).replace(
+      /%3A/gi,
+      ":"
+    );
+  } catch {
+    return encodeURIComponent(segment).replace(/%3A/gi, ":");
+  }
+}
+function jobDetailPath(companySlug, jobSlug) {
+  return `/companies/${encodePathSegment(companySlug)}/jobs/${encodePathSegment(jobSlug)}`;
+}
+function jobsCategoryPath(categorySlug) {
+  return `/jobs/${encodePathSegment(categorySlug)}`;
+}
+function jobsSkillPath(skillSlug) {
+  return `/jobs/skills/${encodePathSegment(skillSlug)}`;
+}
+function jobsLocationPath(placeSlug) {
+  return `/jobs/locations/${encodePathSegment(placeSlug)}`;
+}
+function companyPath(companySlug) {
+  return `/companies/${encodePathSegment(companySlug)}`;
+}
+function companyMarketPath(marketSlug) {
+  return `/companies/markets/${encodePathSegment(marketSlug)}`;
+}
+function companySalaryPath(companySlug) {
+  return `/companies/${encodePathSegment(companySlug)}/salaries`;
+}
+function salaryTitlePath(titleSlug) {
+  return `/salaries/titles/${encodePathSegment(titleSlug)}`;
+}
+function salarySkillPath(skillSlug) {
+  return `/salaries/skills/${encodePathSegment(skillSlug)}`;
+}
+function salaryLocationPath(placeSlug) {
+  return `/salaries/locations/${encodePathSegment(placeSlug)}`;
+}
+function blogPostPath(postSlug) {
+  return `/blog/${encodePathSegment(postSlug)}`;
+}
+function blogTagPath(tagSlug) {
+  return `/blog/tag/${encodePathSegment(tagSlug)}`;
+}
+function blogAuthorPath(authorSlug) {
+  return `/blog/author/${encodePathSegment(authorSlug)}`;
+}
+function talentProfilePath(handle) {
+  return `/p/${encodePathSegment(handle)}`;
+}
+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. 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"],
+  talentProfile: ["handle"],
+  home: [],
+  jobs: [],
+  companies: [],
+  salaries: [],
+  salaryCompanies: [],
+  salaryTitles: [],
+  salarySkills: [],
+  salaryLocations: [],
+  blog: [],
+  about: [],
+  privacyPolicy: [],
+  termsOfService: [],
+  cookiePolicy: [],
+  impressum: [],
+  talent: [],
+  employers: [],
+  alertsManage: [],
+  alertsConfirm: []
+};
+var ALL_ROLES = Object.keys(
+  ROLE_PARAM_REGISTRY
+);
+var ROLE_SET = new Set(ALL_ROLES);
+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"),
+    talentProfile: talentProfilePath(":handle"),
+    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/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,
+  talentProfile: BOARD_PATHS.talent,
+  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("/");
+}
+var PREFIXED_PARAM_RE = /^([^:]+):([A-Za-z_][A-Za-z0-9_]*)(.*)$/;
+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];
+    let name = null;
+    let value = pSeg;
+    if (tSeg.startsWith(":") && tSeg.length > 1) {
+      name = tSeg.slice(1);
+    } else {
+      const prefixed = PREFIXED_PARAM_RE.exec(tSeg);
+      if (prefixed) {
+        const [, prefix = "", param = "", suffix = ""] = prefixed;
+        if (!pSeg.startsWith(prefix) || !pSeg.endsWith(suffix)) return null;
+        name = param;
+        value = pSeg.slice(prefix.length, pSeg.length - suffix.length);
+      }
+    }
+    if (name !== null) {
+      if (value.length === 0) return null;
+      if (value.includes("/") || value.includes("\\")) return null;
+      params[name] = value;
+      continue;
+    }
+    if (tSeg !== pSeg) return null;
+  }
+  return params;
+}
+
+// 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;
+}
+
+// src/route-contract/validate.ts
+var TEMPLATE_CHARSET_RE = /^[A-Za-z0-9/_.:@-]+$/;
+var FIXED_TEXT_ROLES = /* @__PURE__ */ new Set(["talentProfile"]);
+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
+      });
+    }
+    if (FIXED_TEXT_ROLES.has(role) && isParamsOnly(template)) {
+      errors.push({
+        code: "invalid_template",
+        message: `role '${role}' template must carry fixed text around its params (e.g. '/p/:handle' or '/@:handle'), got ${JSON.stringify(template)}`,
+        role
+      });
+    }
+  }
+  return errors;
+}
+function isParamsOnly(template) {
+  return template.replace(/:[A-Za-z_][A-Za-z0-9_]*/g, "").replace(/\//g, "").length === 0;
+}
+
 // src/doctor/checks.ts
 function record(id, tier) {
   return (status, detail) => ({
@@ -114,8 +466,41 @@ function checkEnv(env) {
   return results;
 }
 var JOB_DETAIL_LINK_RE = /href="(\/companies\/[a-z0-9-]+\/jobs\/[a-z0-9-]+)"/i;
-function extractJobDetailLink(html) {
-  return html.match(JOB_DETAIL_LINK_RE)?.[1] ?? null;
+function extractJobDetailLink(html, templates) {
+  if (!templates) return html.match(JOB_DETAIL_LINK_RE)?.[1] ?? null;
+  for (const match of html.matchAll(HREF_PATH_RE)) {
+    const path = match[1];
+    if (path.endsWith("/")) continue;
+    for (const template of templates) {
+      const params = matchPathToTemplate(template, path);
+      if (params && Object.values(params).every((v) => SLUG_RE.test(v))) {
+        return path;
+      }
+    }
+  }
+  return null;
+}
+var HREF_PATH_RE = /href="(\/[^"?#\s]+)"/gi;
+var SLUG_RE = /^[a-z0-9-]+$/i;
+var CANONICAL_JOB_DETAIL_TEMPLATE = CANONICAL_MANIFEST.roles.jobDetail;
+function jobRoutesFromManifest(manifest) {
+  const roles = manifest !== null && typeof manifest === "object" && manifest.version === 1 ? manifest.roles : null;
+  const role = (name) => {
+    const template = roles !== null && typeof roles === "object" ? roles[name] : void 0;
+    return typeof template === "string" && checkRoleTemplate(name, template).length === 0 ? template : null;
+  };
+  const jobs = role("jobs");
+  const company = role("company");
+  const jobsWord = jobs?.split("/").filter((seg) => seg !== "" && !seg.includes(":")).at(-1);
+  const derived = company && jobsWord ? `${company}/${jobsWord}/:jobSlug` : null;
+  const detail = role("jobDetail") ?? (derived && checkRoleTemplate("jobDetail", derived).length === 0 ? derived : null);
+  return {
+    jobsPath: jobs ?? "/jobs",
+    jobDetailTemplates: detail && detail !== CANONICAL_JOB_DETAIL_TEMPLATE ? [detail, CANONICAL_JOB_DETAIL_TEMPLATE] : [CANONICAL_JOB_DETAIL_TEMPLATE]
+  };
+}
+function describeJobDetailTemplate(template) {
+  return template.replace(":companySlug", "{c}").replace(":jobSlug", "{s}").replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, "{$1}");
 }
 var JSON_LD_RE = /<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/gi;
 function extractJobPostingJsonLd(html) {
@@ -8415,9 +8800,19 @@ async function confirmsNoPublishedJobs(fetchImpl, env) {
     return false;
   }
 }
+async function readJobRoutes(fetchImpl, base) {
+  const manifest = await probe(fetchImpl, `${base}/.well-known/cavuno.json`);
+  if (!manifest.ok) return jobRoutesFromManifest(null);
+  try {
+    return jobRoutesFromManifest(JSON.parse(manifest.body));
+  } catch {
+    return jobRoutesFromManifest(null);
+  }
+}
 async function probeJobsAndJsonLd(fetchImpl, base, env) {
-  const jobs = await probe(fetchImpl, `${base}/jobs`);
-  const jobLink = jobs.ok ? extractJobDetailLink(jobs.body) : null;
+  const { jobsPath, jobDetailTemplates } = await readJobRoutes(fetchImpl, base);
+  const jobs = await probe(fetchImpl, `${base}${jobsPath}`);
+  const jobLink = jobs.ok ? extractJobDetailLink(jobs.body, jobDetailTemplates) : null;
   if (jobs.status === 200 && !jobLink && /<(html|body|main)[\s>]/i.test(jobs.body) && await confirmsNoPublishedJobs(fetchImpl, env)) {
     return [
       READ.jobs("pass", "listing renders; API confirms zero published jobs"),
@@ -8426,14 +8821,14 @@ async function probeJobsAndJsonLd(fetchImpl, base, env) {
   }
   const jobsResult = jobs.ok && jobLink ? READ.jobs("pass", `listing renders with job detail links (${jobLink})`) : READ.jobs(
     "fail",
-    jobs.ok ? "listing renders but contains no /companies/{c}/jobs/{s} detail links" : `listing HTTP ${jobs.status}`
+    jobs.ok ? `listing renders but contains no ${describeJobDetailTemplate(jobDetailTemplates[0])} detail links` : `listing HTTP ${jobs.status}`
   );
   if (!jobLink) {
     return [
       jobsResult,
       READ.jsonld(
         "skip",
-        jobs.ok ? "not probed \u2014 the listing rendered no job detail link (see read.jobs failure)" : "not probed \u2014 the /jobs listing itself failed (see read.jobs failure)"
+        jobs.ok ? "not probed \u2014 the listing rendered no job detail link (see read.jobs failure)" : `not probed \u2014 the ${jobsPath} listing itself failed (see read.jobs failure)`
       )
     ];
   }