@cavuno/board 4.42.0 → 4.45.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,42 @@ 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 manifestRoleTemplate(manifest, name) {
+  const roles = manifest !== null && typeof manifest === "object" && manifest.version === 1 ? manifest.roles : null;
+  const template = roles !== null && typeof roles === "object" ? roles[name] : void 0;
+  return typeof template === "string" && checkRoleTemplate(name, template).length === 0 ? template : null;
+}
+function jobRoutesFromManifest(manifest) {
+  const role = (name) => manifestRoleTemplate(manifest, name);
+  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) {
@@ -446,6 +832,25 @@ async function probe(fetchImpl, url) {
     };
   }
 }
+async function probeHop(fetchImpl, url) {
+  try {
+    const response = await fetchImpl(url, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    await response.body?.cancel().catch(() => void 0);
+    return {
+      status: response.status,
+      location: response.headers.get("location")
+    };
+  } catch (error) {
+    return {
+      status: 0,
+      location: null,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 
 // node_modules/.pnpm/parse5@7.3.0/node_modules/parse5/dist/common/unicode.js
 var UNDEFINED_CODE_POINTS = /* @__PURE__ */ new Set([
@@ -8382,6 +8787,142 @@ function hasCrawlableCavunoBacklink(html) {
   return visit(root);
 }
 
+// src/doctor/localized-urls.ts
+var LOCALIZED_URLS = record("read.localizedUrls", 2);
+var REDIRECT_OK = /* @__PURE__ */ new Set([
+  "employers",
+  "alertsManage",
+  "alertsConfirm"
+]);
+var MAY_BE_UNPUBLISHED = /* @__PURE__ */ new Set([
+  "blog",
+  "about",
+  "talent",
+  "privacyPolicy",
+  "termsOfService",
+  "cookiePolicy",
+  "impressum"
+]);
+var GATE_SEGMENTS = /* @__PURE__ */ new Set([
+  "password",
+  "coming-soon-gate"
+]);
+var CONCURRENCY = 1;
+var segments = (path) => path.split("/").filter(Boolean);
+function translatedStaticRoles(manifest) {
+  const translated = [];
+  for (const role of ALL_ROLES) {
+    if (ROLE_PARAM_REGISTRY[role].length > 0 || role === "home") continue;
+    const english = CANONICAL_MANIFEST.roles[role];
+    const localized = manifestRoleTemplate(manifest, role);
+    if (!english || !localized || localized === english) continue;
+    if (segments(localized).length !== segments(english).length) continue;
+    translated.push({ role, english, localized });
+  }
+  return translated;
+}
+function resolveLocation(location, requestUrl) {
+  try {
+    return new URL(location, requestUrl);
+  } catch {
+    return null;
+  }
+}
+function pathUnder(base, url) {
+  const prefix = base.pathname.replace(/\/$/, "");
+  const path = prefix && url.pathname.startsWith(prefix) ? url.pathname.slice(prefix.length) || "/" : url.pathname;
+  return `${path}${url.search}`;
+}
+function isGate(base, url, requested) {
+  const parts = segments(pathUnder(base, url).split("?")[0]);
+  const last = parts.at(-1);
+  if (last !== void 0 && GATE_SEGMENTS.has(last)) return true;
+  return parts.length === 1 && url.searchParams.get("redirect") === requested;
+}
+async function checkRole(fetchImpl, baseUrl, { role, english, localized }) {
+  const base = new URL(baseUrl);
+  const problems = [];
+  const englishUrl = `${baseUrl}${english}`;
+  const hop = await probeHop(fetchImpl, englishUrl);
+  const target = hop.location === null ? null : resolveLocation(hop.location, englishUrl);
+  if (hop.status !== 308) {
+    problems.push(
+      `${english} \u2192 HTTP ${hop.status}${hop.error ? ` (${hop.error})` : ""}${target ? ` to ${target.href}` : ""}, expected 308 to ${localized}`
+    );
+  } else if (target === null) {
+    problems.push(
+      `${english} \u2192 308 without a usable Location, expected ${localized}`
+    );
+  } else if (target.origin !== base.origin) {
+    problems.push(
+      `${english} \u2192 308 off the board's origin to ${target.href}, expected ${localized}`
+    );
+  } else if (pathUnder(base, target) !== localized) {
+    problems.push(
+      `${english} \u2192 308 to ${pathUnder(base, target)}, expected ${localized}`
+    );
+  }
+  const pageUrl = `${baseUrl}${localized}`;
+  const page = await probeHop(fetchImpl, pageUrl);
+  const pageTarget = page.location === null ? null : resolveLocation(page.location, pageUrl);
+  const ok2xx = page.status >= 200 && page.status < 300;
+  const redirected = page.status >= 300 && page.status < 400;
+  if (ok2xx) {
+  } else if (page.status === 404 && MAY_BE_UNPUBLISHED.has(role)) {
+  } else if (redirected && pageTarget === null) {
+    problems.push(
+      `${localized} \u2192 HTTP ${page.status} without a usable Location, expected 2xx`
+    );
+  } else if (redirected && pageTarget.origin !== base.origin) {
+    problems.push(
+      `${localized} \u2192 HTTP ${page.status} off the board's origin to ${pageTarget.href}, expected 2xx`
+    );
+  } else if (redirected && isGate(base, pageTarget, localized)) {
+    problems.push(
+      `${localized} \u2192 HTTP ${page.status} to the board's access gate ${pathUnder(base, pageTarget)}, expected 2xx`
+    );
+  } else if (!(redirected && REDIRECT_OK.has(role))) {
+    problems.push(
+      `${localized} \u2192 HTTP ${page.status}${page.error ? ` (${page.error})` : ""}${pageTarget ? ` to ${pathUnder(base, pageTarget)}` : ""}, expected 2xx`
+    );
+  }
+  return problems.length > 0 ? `${role}: ${problems.join("; ")}` : null;
+}
+async function probeLocalizedUrls(fetchImpl, base, manifest) {
+  if (manifest === null) {
+    return LOCALIZED_URLS(
+      "skip",
+      "not applicable \u2014 no readable route manifest at /.well-known/cavuno.json"
+    );
+  }
+  const roles = translatedStaticRoles(manifest);
+  if (roles.length === 0) {
+    return LOCALIZED_URLS(
+      "skip",
+      "not applicable \u2014 the route manifest publishes no translated URL words"
+    );
+  }
+  const failures = new Array(roles.length).fill(null);
+  let next = 0;
+  const worker = async () => {
+    while (next < roles.length) {
+      const index = next++;
+      failures[index] = await checkRole(fetchImpl, base, roles[index]);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(CONCURRENCY, roles.length) }, worker)
+  );
+  const failed = failures.filter((f) => f !== null);
+  if (failed.length > 0) {
+    return LOCALIZED_URLS("fail", failed.join(" | "));
+  }
+  return LOCALIZED_URLS(
+    "pass",
+    `${roles.length} translated pages: each English path 308s to the board's word and the page answers (${roles.map((r) => `${r.english} \u2192 ${r.localized}`).join(", ")})`
+  );
+}
+
 // src/doctor/read.ts
 var READ = {
   home: record("read.home", 2),
@@ -8394,7 +8935,8 @@ var READ = {
   indexNow: record("read.indexNow", 2),
   googleVerification: record("read.googleVerification", 2),
   attribution: record("read.attribution", 2),
-  oauthCallback: record("read.oauthCallback", 2)
+  oauthCallback: record("read.oauthCallback", 2),
+  localizedUrls: LOCALIZED_URLS
 };
 function skipReadProbes(reason) {
   return Object.values(READ).map((make) => make("skip", reason));
@@ -8415,9 +8957,19 @@ async function confirmsNoPublishedJobs(fetchImpl, env) {
     return false;
   }
 }
-async function probeJobsAndJsonLd(fetchImpl, base, env) {
-  const jobs = await probe(fetchImpl, `${base}/jobs`);
-  const jobLink = jobs.ok ? extractJobDetailLink(jobs.body) : null;
+async function readManifest(fetchImpl, base) {
+  const manifest = await probe(fetchImpl, `${base}/.well-known/cavuno.json`);
+  if (!manifest.ok) return null;
+  try {
+    return JSON.parse(manifest.body);
+  } catch {
+    return null;
+  }
+}
+async function probeJobsAndJsonLd(fetchImpl, base, manifest, env) {
+  const { jobsPath, jobDetailTemplates } = jobRoutesFromManifest(manifest);
+  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 +8978,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)`
       )
     ];
   }
@@ -8664,7 +9216,13 @@ function scoreOAuthCallback(probed) {
 async function runReadProbes(fetchImpl, frontendUrl, seo, env) {
   const base = frontendUrl.replace(/\/$/, "");
   const home = await probe(fetchImpl, base);
-  const jobsAndJsonLd = await probeJobsAndJsonLd(fetchImpl, base, env);
+  const manifest = await readManifest(fetchImpl, base);
+  const jobsAndJsonLd = await probeJobsAndJsonLd(
+    fetchImpl,
+    base,
+    manifest,
+    env
+  );
   const sitemap = await probeSitemap(fetchImpl, base);
   const robots = await probe(fetchImpl, `${base}/robots.txt`);
   const adsTxt = await probe(fetchImpl, `${base}/ads.txt`);
@@ -8679,6 +9237,7 @@ async function runReadProbes(fetchImpl, frontendUrl, seo, env) {
       `${base}/api/board-auth/oauth/linkedin/callback`
     )
   };
+  const localizedUrls = await probeLocalizedUrls(fetchImpl, base, manifest);
   const board = env?.apiUrl && env.boardKey ? await probe(
     fetchImpl,
     `${apiBase(env.apiUrl)}/v1/boards/${encodeURIComponent(env.boardKey)}`
@@ -8717,7 +9276,8 @@ async function runReadProbes(fetchImpl, frontendUrl, seo, env) {
     }),
     scoreGoogleVerification(home.body, seo),
     attribution,
-    scoreOAuthCallback(oauthCallback)
+    scoreOAuthCallback(oauthCallback),
+    localizedUrls
   ];
 }