jd-intel 0.8.2 → 0.9.0

package/src/adapters/workday.js

@@ -1,9 +1,14 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const MAX_DETAIL_FETCHES = 100;
 const LIST_PAGE_SIZE = 20;
-const LIST_PAGE_HARD_CAP = 100; // <= 2000 list items scanned per request
+// Upper bound on list pages per call: 100 pages of 20 = at most 2000
+// postings scanned. Paging usually stops sooner, on a short page or when
+// offset reaches the first page's total (see the loop below).
+const LIST_PAGE_HARD_CAP = 100;
+// A multi-location posting's list row reads "2 Locations", "14 Locations".
+const MULTI_LOCATION = /^\s*\d+\s+locations?\s*$/;
 
 /**
  * Fetch jobs from a Workday tenant via the public "CXS" JSON API.
@@ -40,6 +45,7 @@ export async function fetchWorkday(slug, ctx = {}) {
   const postings = [];
   let offset = 0;
   let pages = 0;
+  let firstTotal = 0;
   while (pages < LIST_PAGE_HARD_CAP) {
     const resp = await fetch(`${base}/jobs`, {
       method: 'POST',
@@ -48,19 +54,24 @@ export async function fetchWorkday(slug, ctx = {}) {
     });
 
     if (!resp.ok) {
-      if (resp.status === 404) return []; // wrong site / no such board
       if (offset === 0) {
+        if (resp.status === 404) return []; // wrong site / no such board
         throw atsErrorFromStatus(resp.status, `Workday API error for ${slug} (${tenant}/${env}/${site}): ${resp.status}`);
       }
-      break; // mid-paging failure: keep what we have
+      break; // mid-paging failure (any status): keep what we have
     }
 
     const data = await resp.json();
     const page = data.jobPostings || [];
+    // Some tenants report the real `total` only at offset 0 and send
+    // `total: 0` on every later page, so only the first page's figure
+    // is trusted. A short page is the other stop signal.
+    if (pages === 0) firstTotal = data.total || 0;
     postings.push(...page);
     pages += 1;
     offset += LIST_PAGE_SIZE;
-    if (page.length === 0 || offset >= (data.total || 0)) break;
+    if (page.length < LIST_PAGE_SIZE) break;
+    if (firstTotal > 0 && offset >= firstTotal) break;
   }
 
   // 2. Filter-aware candidate selection BEFORE the N+1 detail cost.
@@ -76,6 +87,9 @@ export async function fetchWorkday(slug, ctx = {}) {
     const inc = fc.locationIncludes.map(s => String(s).toLowerCase());
     candidates = candidates.filter(p => {
       const loc = (p.locationsText || '').toLowerCase();
+      // "2 Locations" says nothing about where. The row stays a candidate
+      // and the pass after hydration decides on the detail's location list.
+      if (MULTI_LOCATION.test(loc)) return true;
       return inc.some(s => loc.includes(s));
     });
   }
@@ -91,16 +105,21 @@ export async function fetchWorkday(slug, ctx = {}) {
   }
 
   // 3. Bound the detail-fetch set.
-  //    NOTE: huge-tenant coverage is intentionally capped for v1
-  //    (Salesforce ~1398 postings). A description `filter` is applied
-  //    by the library AFTER this returns, so for that case we keep the
-  //    full backstop instead of truncating tightly to `limit` (which
-  //    could hydrate jobs that all fail the regex while better matches
-  //    go unscanned). Proper fix (smart pagination / rate-limited
-  //    concurrency / surfaced truncation) is tracked in #26, to be
-  //    designed alongside retry/rate-limit work (#7).
+  //    NOTE: huge-tenant coverage is intentionally capped for v1. Two
+  //    caps apply: the list scan above stops at LIST_PAGE_HARD_CAP pages
+  //    (2000 postings, enough for Salesforce's ~1398), and the detail set
+  //    is cut to MAX_DETAIL_FETCHES here. A description `filter` is
+  //    applied by the library AFTER this returns, so for that case we
+  //    keep the full backstop instead of truncating tightly to `limit`
+  //    (which could hydrate jobs that all fail the regex while better
+  //    matches go unscanned). The library pages with `offset` after this
+  //    returns, so the budget covers the page plus what precedes it.
+  //    Proper fix (smart pagination / rate-limited concurrency / surfaced
+  //    truncation) is tracked in #26, to be designed alongside
+  //    retry/rate-limit work (#7).
   const limit = typeof fc.limit === 'number' && fc.limit > 0 ? fc.limit : 100;
-  const cap = fc.filter ? MAX_DETAIL_FETCHES : Math.min(limit, MAX_DETAIL_FETCHES);
+  const skip = typeof fc.offset === 'number' && fc.offset > 0 ? fc.offset : 0;
+  const cap = fc.filter ? MAX_DETAIL_FETCHES : Math.min(skip + limit, MAX_DETAIL_FETCHES);
   candidates = candidates.slice(0, cap);
 
   // 4. Hydrate descriptions via the per-posting detail endpoint.
@@ -126,7 +145,9 @@ export async function fetchWorkday(slug, ctx = {}) {
       title: p.title || info.title || '',
       department: '',
       location: info.location || p.locationsText || '',
-      description: stripHtml(info.jobDescription || ''),
+      locations: info.additionalLocations || [],
+      workplace: parseWorkdayRemoteType(info.remoteType),
+      description: info.jobDescription || '',
       url: `https://${tenant}.${env}.myworkdayjobs.com/${site}${externalPath}`,
       postedAt: parseWorkdayDate(info.startDate) || normalizePostedOn(p.postedOn),
       salary: null, // normalizer extracts from description text
@@ -142,6 +163,20 @@ export async function fetchWorkday(slug, ctx = {}) {
   return jobs;
 }
 
+/**
+ * Detail `remoteType` is free text set per tenant: "Remote", "Hybrid",
+ * "Office - Flexible", "On-site". A flexible office arrangement counts as
+ * hybrid, so that check runs before the office one. Some tenants send no
+ * value at all; the location string decides then.
+ */
+function parseWorkdayRemoteType(remoteType) {
+  const s = String(remoteType || '').toLowerCase();
+  if (/remote/.test(s)) return 'remote';
+  if (/hybrid|flexible/.test(s)) return 'hybrid';
+  if (/office|on-?site/.test(s)) return 'onsite';
+  return null;
+}
+
 /**
  * Workday list `postedOn` is a relative string ("Posted Today",
  * "Posted 5 Days Ago", "Posted 30+ Days Ago"). Decide membership in

package/src/cli.js

@@ -9,6 +9,8 @@
  *   jd-intel registry search <query>
  */
 
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { fetchJobs } from './index.js';
 import { detectAts, searchRegistry } from './registry.js';
 
@@ -85,7 +87,7 @@ async function main() {
       console.log(`Found ${jobs.length} jobs\n`);
 
       for (const job of jobs.slice(0, 20)) {
-        const salary = job.salary ? ` | $${job.salary.min?.toLocaleString()}-$${job.salary.max?.toLocaleString()}` : '';
+        const salary = job.salary ? ` | ${formatSalary(job.salary)}` : '';
         const loc = job.location ? ` | ${job.location}` : '';
         const dept = job.department ? ` [${job.department}]` : '';
         console.log(`  ${job.title}${dept}${loc}${salary}`);
@@ -162,8 +164,8 @@ Fetch options:
   --title-filter pattern          Regex matched against TITLE only (role identity)
   --filter pattern                Regex matched across title, department, description (topic/scope)
   --posted-within-days N          Only jobs posted in the last N days
-  --location-include "A,B,C"      Keep jobs whose location contains any of these
-  --location-exclude "A,B,C"      Drop jobs whose location contains any of these
+  --location-include "A,B,C"      Keep jobs where any listed location contains one of these
+  --location-exclude "A,B,C"      Drop jobs only when every listed location contains one of these
   --limit N                       Cap results (default 100)
   --json                          Output full JSON
 
@@ -184,7 +186,32 @@ Examples:
   }
 }
 
-main().catch(err => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+export function formatSalary({ min, max, currency, period }) {
+  const hasMin = min != null;
+  const hasMax = max != null;
+  let range;
+  if (hasMin && hasMax) range = `${min.toLocaleString()}-${max.toLocaleString()}`;
+  else if (hasMin) range = `from ${min.toLocaleString()}`;
+  else range = `up to ${max.toLocaleString()}`;
+  const unit = period === 'hour' ? '/hr' : period === 'month' ? '/mo' : '';
+  return `${range} ${currency}${unit}`;
+}
+
+// Boot only when this file is the script Node was started with, so a test
+// can import formatSalary without running a command. argv[1] is resolved
+// through realpath because npm installs the bin as a symlink into .bin/,
+// while import.meta.url already points at the real file.
+function isEntrypoint() {
+  try {
+    return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+
+if (isEntrypoint()) {
+  main().catch(err => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+}

package/src/filters.js

@@ -4,14 +4,33 @@
  * Facts go here (deterministic field matches). Interpretations stay with the
  * caller — this module does substring matching on structured fields, nothing
  * semantic.
+ *
+ * Returns the page as an array. applyFiltersDetailed returns the same page
+ * plus total_matched, the match count before offset and limit.
  */
 export function applyFilters(jobs, options = {}) {
+  return applyFiltersDetailed(jobs, options).jobs;
+}
+
+/**
+ * Filter, sort, then page.
+ *
+ * Order is applied after the filters and before offset and limit, so a cut
+ * drops the oldest matches first. 'newest' sorts by postedAt descending with
+ * undated jobs last and ties broken by id, which keeps pages deterministic.
+ * 'board' keeps the order the adapter returned.
+ *
+ * @returns {{ jobs: Array, total_matched: number }}
+ */
+export function applyFiltersDetailed(jobs, options = {}) {
   const {
     titleFilter,
     filter,
     postedWithinDays,
     locationIncludes,
     locationExcludes,
+    order = 'newest',
+    offset = 0,
     limit = 100,
   } = options;
 
@@ -42,25 +61,60 @@ export function applyFilters(jobs, options = {}) {
 
   if (Array.isArray(locationIncludes) && locationIncludes.length > 0) {
     const matchers = locationIncludes.map(makeLocationMatcher);
-    result = result.filter(j => {
-      const loc = (j.location || '').toLowerCase();
-      return matchers.some(m => m(loc));
-    });
+    result = result.filter(j => jobLocations(j).some(loc => matchers.some(m => m(loc))));
   }
 
   if (Array.isArray(locationExcludes) && locationExcludes.length > 0) {
     const matchers = locationExcludes.map(makeLocationMatcher);
-    result = result.filter(j => {
-      const loc = (j.location || '').toLowerCase();
-      return !matchers.some(m => m(loc));
-    });
+    result = result.filter(j => !jobLocations(j).every(loc => matchers.some(m => m(loc))));
   }
 
-  if (typeof limit === 'number' && result.length > limit) {
-    result = result.slice(0, limit);
+  const total_matched = result.length;
+
+  if (order !== 'board') {
+    result = [...result].sort(byNewest);
   }
 
-  return result;
+  const start = typeof offset === 'number' && offset > 0 ? offset : 0;
+  const end = typeof limit === 'number' ? start + limit : undefined;
+  if (start > 0 || (end !== undefined && result.length > end)) {
+    result = result.slice(start, end);
+  }
+
+  return { jobs: result, total_matched };
+}
+
+/**
+ * Every location a job is open in, lowercased. A job passes an include when
+ * any of them matches and is dropped by an exclude only when all of them
+ * match: a role open in Berlin and New York is still open in Berlin for
+ * someone excluding the US (issue #68). Jobs from before `locations`
+ * existed fall back to the single `location` string.
+ */
+function jobLocations(job) {
+  const list = Array.isArray(job.locations) && job.locations.length > 0
+    ? job.locations
+    : [job.location || ''];
+  return list.map(loc => String(loc).toLowerCase());
+}
+
+function postedTime(job) {
+  if (!job.postedAt) return null;
+  const t = new Date(job.postedAt).getTime();
+  return Number.isFinite(t) ? t : null;
+}
+
+function byNewest(a, b) {
+  const ta = postedTime(a);
+  const tb = postedTime(b);
+  if (ta !== tb) {
+    if (ta === null) return 1;
+    if (tb === null) return -1;
+    return tb - ta;
+  }
+  const ia = a.id || '';
+  const ib = b.id || '';
+  return ia < ib ? -1 : ia > ib ? 1 : 0;
 }
 
 /**

package/src/index.js

@@ -8,11 +8,23 @@
 
 import { ADAPTERS, ATS_NAMES } from './adapters/index.js';
 import { loadRegistry, searchRegistry, detectAts, findAtsBySlug, findEntryBySlug, getRegistrySource } from './registry.js';
-import { applyFilters } from './filters.js';
+import { applyFiltersDetailed } from './filters.js';
 
 /**
  * Fetch jobs from a company's ATS board.
  *
+ * Same options as fetchJobsDetailed; returns the page as an array.
+ *
+ * @returns {Promise<Array>} Normalized, filtered job objects
+ */
+export async function fetchJobs(options = {}) {
+  const { jobs } = await fetchJobsDetailed(options);
+  return jobs;
+}
+
+/**
+ * Fetch jobs from a company's ATS board, with the match count.
+ *
  * @param {Object} options
  * @param {string} options.company - Company slug or name
  * @param {string} [options.ats] - Specific ATS platform. If omitted, auto-detects.
@@ -20,12 +32,14 @@ import { applyFilters } from './filters.js';
  * @param {string} [options.titleFilter] - Regex matched against title only. Use for role identity ("product manager", "staff engineer").
  * @param {string} [options.filter] - Regex matched across title, department, description. Use for topic/scope.
  * @param {number} [options.postedWithinDays] - Only return jobs posted within N days.
- * @param {string[]} [options.locationIncludes] - Keep jobs whose location contains any of these (case-insensitive).
- * @param {string[]} [options.locationExcludes] - Drop jobs whose location contains any of these (case-insensitive).
- * @param {number} [options.limit=100] - Maximum jobs to return after filtering.
- * @returns {Promise<Array>} Normalized, filtered job objects
+ * @param {string[]} [options.locationIncludes] - Keep jobs where any listed location contains any of these (case-insensitive).
+ * @param {string[]} [options.locationExcludes] - Drop jobs only when every listed location contains one of these (case-insensitive).
+ * @param {'newest'|'board'} [options.order='newest'] - 'newest': by postedAt descending, undated last, ties by id. 'board': the adapter's own order.
+ * @param {number} [options.offset=0] - Matches to skip after sorting (paging).
+ * @param {number} [options.limit=100] - Maximum jobs to return after offset.
+ * @returns {Promise<{ jobs: Array, total_matched: number }>} The page, plus the match count before offset and limit
  */
-export async function fetchJobs({
+export async function fetchJobsDetailed({
   company,
   ats,
   config,
@@ -34,6 +48,8 @@ export async function fetchJobs({
   postedWithinDays,
   locationIncludes,
   locationExcludes,
+  order = 'newest',
+  offset = 0,
   limit = 100,
 } = {}) {
   if (!company) throw new Error('Company slug required');
@@ -45,7 +61,7 @@ export async function fetchJobs({
   // adapters declare fetch{Name}(slug) and ignore extra positional args
   // (JS no-op), so this is backward-compatible. Filter-aware adapters
   // (e.g. Workday) use it to avoid mass detail-fetching on huge tenants.
-  const filterContext = { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit };
+  const filterContext = { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, offset, limit };
 
   let jobs;
   if (ats) {
@@ -93,7 +109,7 @@ export async function fetchJobs({
     }
   }
 
-  return applyFilters(jobs, { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit });
+  return applyFiltersDetailed(jobs, { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, order, offset, limit });
 }
 
 /**
@@ -134,7 +150,7 @@ export { fetchLever } from './adapters/lever.js';
 export { fetchAshby } from './adapters/ashby.js';
 
 // Re-export filter logic for reuse (e.g., by the MCP server)
-export { applyFilters } from './filters.js';
+export { applyFilters, applyFiltersDetailed } from './filters.js';
 
 // Re-export the list of supported ATS names (e.g. so the MCP layer can report
 // the full set detectAts probes, instead of hardcoding a stale subset).

package/src/normalizer.js

@@ -13,20 +13,35 @@ export function jobId(company, title, ats, location = '') {
 
 /**
  * Normalize a raw ATS job object into the unified schema.
+ *
+ * Adapters pass `description` as HTML. This is the one place it is
+ * stripped and decoded (issue #66): a second pass would delete text the
+ * author escaped on purpose (`<5 years`) and leave entities the first
+ * pass exposed (`—` -> `—`) as literal noise.
+ *
+ * `raw.workplace` is the ATS's own arrangement, already mapped by the
+ * adapter to 'remote' | 'hybrid' | 'onsite', or null when the platform
+ * gives no signal. `raw.locations` lists every place the posting is open
+ * in; `location` stays the primary because it feeds the id (issue #68).
  */
 export function normalize(raw, ats) {
   const now = new Date().toISOString();
+  const description = stripHtml(raw.description || '');
+  const location = raw.location || '';
+  const workplace = resolveWorkplace(raw.workplace, location);
   return {
-    id: jobId(raw.company || raw.companySlug, raw.title, ats, raw.location || ''),
+    id: jobId(raw.company || raw.companySlug, raw.title, ats, location),
     company: raw.company || raw.companySlug || '',
     companySlug: raw.companySlug || '',
     ats,
     title: raw.title || '',
     department: raw.department || '',
-    location: raw.location || '',
-    locationType: detectLocationType(raw.location || ''),
-    salary: raw.salary || extractSalaryFromText(raw.description || ''),
-    description: stripHtml(raw.description || ''),
+    location,
+    locations: uniqueLocations(location, raw.locations),
+    locationType: workplace.type,
+    workplace,
+    salary: raw.salary || extractSalaryFromText(description),
+    description,
     url: raw.url || '',
     postedAt: raw.postedAt || null,
     firstSeen: now,
@@ -36,62 +51,203 @@ export function normalize(raw, ats) {
   };
 }
 
+const CURRENCY_CODES = 'USD|EUR|GBP|CAD|AUD|NZD|CHF|SEK|NOK|DKK|PLN|CZK|HUF|INR|SGD|HKD|JPY|CNY|BRL|MXN|ZAR|AED|ILS';
+const SYMBOL_CURRENCY = { $: 'USD', '€': 'EUR', '£': 'GBP' };
+
+// A number as job posts write it: 1,234,567 / 1.234.567 / 1234, with an
+// optional one- or two-digit decimal part (211.4, 40.50, 60.000,50).
+// Exactly three digits after a dot are a thousands group, the way Dutch
+// and German boards write it: "€60.000" is sixty thousand, not sixty.
+const NUMBER =
+  '\\d{1,3}(?:,\\d{3})+(?:\\.\\d{1,2})?' +
+  '|\\d{1,3}(?:\\.\\d{3})+(?:,\\d{1,2})?' +
+  '|\\d+(?:[.,]\\d{1,2})?';
+
+// One side of a range: optional code before, optional symbol, the number,
+// optional K, optional code after. The lookarounds keep the number from
+// starting or ending inside a longer one ("234.567" out of "1.234.567").
+const amountPattern = (p) =>
+  `(?:\\b(?<${p}CodeBefore>${CURRENCY_CODES})\\s?)?` +
+  `(?<${p}Sym>[$€£])?\\s?` +
+  `(?<![\\d.,])(?<${p}Num>${NUMBER})(?!\\d|[.,]\\d)\\s?` +
+  `(?<${p}K>[kK]\\b)?` +
+  `(?:\\s?(?<${p}CodeAfter>${CURRENCY_CODES})\\b)?`;
+
+const SALARY_RANGE = new RegExp(
+  `${amountPattern('lo')}\\s*(?:[-–—]|\\bto\\b)\\s*${amountPattern('hi')}`,
+  'g'
+);
+
+const HOUR_RE = /\b(?:per|an|each)\s+hour\b|\/\s*(?:hr|hour)\b|\bhourly\b/i;
+const MONTH_RE = /\b(?:per|a|each)\s+month\b|\/\s*(?:mo|month)\b|\bmonthly\b/i;
+const YEAR_RE = /\b(?:per|a|each)\s+(?:year|annum)\b|\/\s*(?:yr|year)\b|\b(?:annual(?:ly|ized)?|yearly)\b/i;
+
 /**
- * Detect location type from location string.
- */
-/**
- * Extract salary range from job description text.
- * Matches patterns like: $162,400 - $243,600 or $150K-$200K
+ * Extract a salary range from decoded job text.
+ *
+ * Accepts hyphen, en dash, em dash or "to" between the two amounts, an
+ * optional ISO currency code before, between or after them, `$` / EUR /
+ * GBP symbols, decimal K shorthand ($211.4K), and thousands grouped with
+ * either a comma or a dot (60,000 and 60.000 are both sixty thousand).
+ * A code wins over a symbol, so "$120,000 - $150,000 CAD" is CAD. Ranges
+ * with no currency marker at all (years, headcounts) are ignored.
+ *
+ * @returns {{min:number,max:number,currency:string,period:('year'|'month'|'hour'|null),source:'text'}|null}
  */
-function extractSalaryFromText(text) {
+export function extractSalaryFromText(text) {
   if (!text) return null;
-  // Match: $162,400 - $243,600 (full numbers)
-  const fullMatch = text.match(/\$([\d,]+)\s*[-–]\s*\$([\d,]+)/);
-  if (fullMatch) {
-    return {
-      min: parseInt(fullMatch[1].replace(/,/g, '')),
-      max: parseInt(fullMatch[2].replace(/,/g, '')),
-      currency: 'USD',
-    };
-  }
-  // Match: $150K - $200K (shorthand)
-  const kMatch = text.match(/\$(\d+)[kK]\s*[-–]\s*\$(\d+)[kK]/);
-  if (kMatch) {
+  for (const m of text.matchAll(SALARY_RANGE)) {
+    const g = m.groups;
+    const end = m.index + m[0].length;
+    const after = text.slice(end, end + 40);
+    // "$20 - $30 million" is a revenue figure, not pay.
+    if (/^\s*(?:million|billion|m|bn?)\b/i.test(after)) continue;
+
+    const code = g.loCodeBefore || g.loCodeAfter || g.hiCodeBefore || g.hiCodeAfter;
+    const sym = g.loSym || g.hiSym;
+    if (!code && !sym) continue;
+
+    let min = parseAmount(g.loNum);
+    let max = parseAmount(g.hiNum);
+    if (g.loK || g.hiK) {
+      // "$150-200K" carries the K once for both sides.
+      if (min < 1000) min = Math.round(min * 1000);
+      if (max < 1000) max = Math.round(max * 1000);
+    }
+    if (!(min > 0) || !(max > 0)) continue;
+
+    const before = text.slice(Math.max(0, m.index - 40), m.index);
     return {
-      min: parseInt(kMatch[1]) * 1000,
-      max: parseInt(kMatch[2]) * 1000,
-      currency: 'USD',
+      min,
+      max,
+      currency: (code || SYMBOL_CURRENCY[sym]).toUpperCase(),
+      period: detectPeriod(before, after, min),
+      source: 'text',
     };
   }
   return null;
 }
 
-function detectLocationType(location) {
-  const lower = location.toLowerCase();
-  if (/remote/i.test(lower)) return 'remote';
-  if (/hybrid/i.test(lower)) return 'hybrid';
-  if (/on-?site/i.test(lower)) return 'onsite';
-  return location ? 'onsite' : 'unknown';
+// Dots grouping thousands mean a comma is the decimal mark, and vice versa.
+function parseAmount(s) {
+  if (/^\d{1,3}(?:\.\d{3})+/.test(s)) return Number(s.replace(/\./g, '').replace(',', '.'));
+  return Number(s.replace(/,(?=\d{3})/g, '').replace(',', '.'));
+}
+
+function detectPeriod(before, after, min) {
+  const explicit = periodWord(after) || periodWord(before);
+  if (explicit) return explicit;
+  return min >= 10000 ? 'year' : null;
+}
+
+function periodWord(text) {
+  if (HOUR_RE.test(text)) return 'hour';
+  if (MONTH_RE.test(text)) return 'month';
+  if (YEAR_RE.test(text)) return 'year';
+  return null;
+}
+
+const WORKPLACE_TYPES = new Set(['remote', 'hybrid', 'onsite']);
+
+/**
+ * The platform's own value wins. Without one, a keyword in the location
+ * string is the next best signal. Without either the type is 'unknown':
+ * a city name alone does not say the role is onsite, and a guessed
+ * 'onsite' reads as a fact to whoever consumes it.
+ *
+ * @returns {{type:('remote'|'hybrid'|'onsite'|'unknown'), source:('ats'|'text'|null)}}
+ */
+function resolveWorkplace(native, location) {
+  if (WORKPLACE_TYPES.has(native)) return { type: native, source: 'ats' };
+  const guessed = workplaceFromText(location);
+  if (guessed) return { type: guessed, source: 'text' };
+  return { type: 'unknown', source: null };
+}
+
+function workplaceFromText(location) {
+  const lower = (location || '').toLowerCase();
+  if (/remote/.test(lower)) return 'remote';
+  if (/hybrid/.test(lower)) return 'hybrid';
+  if (/on-?site/.test(lower)) return 'onsite';
+  return null;
+}
+
+function uniqueLocations(primary, extra) {
+  const out = [];
+  const seen = new Set();
+  for (const loc of [primary, ...(Array.isArray(extra) ? extra : [])]) {
+    const s = typeof loc === 'string' ? loc.trim() : '';
+    if (!s || seen.has(s.toLowerCase())) continue;
+    seen.add(s.toLowerCase());
+    out.push(s);
+  }
+  return out;
 }
 
 /**
  * Strip HTML tags and convert to clean text.
+ *
+ * Block closers become line breaks and list items become bullets before
+ * the remaining tags are removed. Entities are decoded LAST, so a literal
+ * `&lt;` in the source text never turns into a tag that gets stripped.
  */
 export function stripHtml(html) {
   if (!html) return '';
-  return html
+  const text = html
     .replace(/<br\s*\/?>/gi, '\n')
-    .replace(/<\/p>/gi, '\n\n')
-    .replace(/<\/li>/gi, '\n')
-    .replace(/<li>/gi, '- ')
-    .replace(/<\/h[1-6]>/gi, '\n\n')
-    .replace(/<h[1-6][^>]*>/gi, '## ')
-    .replace(/<[^>]+>/g, '')
-    .replace(/&amp;/g, '&')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&nbsp;/g, ' ')
-    .replace(/&#\d+;/g, '')
+    .replace(/<\/(?:p|h[1-6])\s*>/gi, '\n\n')
+    .replace(/<\/(?:li|div|td|tr|ul|ol|table|section)\s*>/gi, '\n')
+    // Word-pasted markup (Lever lists, issue #64) opens a <p> inside each
+    // <li>; swallowing it keeps the item text on the bullet's line.
+    .replace(/<li\b[^>]*>\s*(?:<p\b[^>]*>\s*)?/gi, '- ')
+    .replace(/<h[1-6]\b[^>]*>/gi, '## ')
+    .replace(/<[^>]+>/g, '');
+  return decodeEntities(text)
+    .replace(/\u00a0/g, ' ')
     .replace(/\n{3,}/g, '\n\n')
     .trim();
 }
+
+const NAMED_ENTITIES = {
+  lt: '<', gt: '>', quot: '"', apos: "'", nbsp: '\u00a0',
+  mdash: '—', ndash: '–', hellip: '…',
+  lsquo: '‘', rsquo: '’', ldquo: '“', rdquo: '”',
+  sbquo: '‚', bdquo: '„', laquo: '«', raquo: '»',
+  bull: '•', middot: '·', copy: '©', reg: '®', trade: '™',
+  deg: '°', times: '×', euro: '€', pound: '£', yen: '¥', cent: '¢',
+  agrave: 'à', aacute: 'á', acirc: 'â', atilde: 'ã', auml: 'ä', aring: 'å', aelig: 'æ',
+  ccedil: 'ç', egrave: 'è', eacute: 'é', ecirc: 'ê', euml: 'ë',
+  igrave: 'ì', iacute: 'í', icirc: 'î', iuml: 'ï', ntilde: 'ñ',
+  ograve: 'ò', oacute: 'ó', ocirc: 'ô', otilde: 'õ', ouml: 'ö', oslash: 'ø',
+  ugrave: 'ù', uacute: 'ú', ucirc: 'û', uuml: 'ü', yacute: 'ý', yuml: 'ÿ', szlig: 'ß',
+  Agrave: 'À', Aacute: 'Á', Acirc: 'Â', Atilde: 'Ã', Auml: 'Ä', Aring: 'Å', AElig: 'Æ',
+  Ccedil: 'Ç', Egrave: 'È', Eacute: 'É', Ecirc: 'Ê', Euml: 'Ë',
+  Igrave: 'Ì', Iacute: 'Í', Icirc: 'Î', Iuml: 'Ï', Ntilde: 'Ñ',
+  Ograve: 'Ò', Oacute: 'Ó', Ocirc: 'Ô', Otilde: 'Õ', Ouml: 'Ö', Oslash: 'Ø',
+  Ugrave: 'Ù', Uacute: 'Ú', Ucirc: 'Û', Uuml: 'Ü', Yacute: 'Ý',
+};
+
+/**
+ * Decode one layer of entity encoding (and unwrap CDATA) to real text.
+ *
+ * Decimal and hex references go through String.fromCodePoint, named
+ * references through the table above. `&amp;` is intentionally resolved
+ * LAST so double-encoded sequences (`&amp;mdash;`, `&amp;amp;`) collapse
+ * by exactly one layer per call. Used for the outer escaping Greenhouse
+ * and the Teamtailor RSS feed apply, and as stripHtml's final step.
+ */
+export function decodeEntities(s) {
+  if (!s) return '';
+  return s
+    .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
+    .replace(/&#(\d+);/g, (m, dec) => codePointToString(parseInt(dec, 10), m))
+    .replace(/&#[xX]([0-9a-fA-F]+);/g, (m, hex) => codePointToString(parseInt(hex, 16), m))
+    .replace(/&([A-Za-z][A-Za-z0-9]*);/g, (m, name) =>
+      (name !== 'amp' && Object.hasOwn(NAMED_ENTITIES, name)) ? NAMED_ENTITIES[name] : m)
+    .replace(/&amp;/g, '&');
+}
+
+function codePointToString(cp, fallback) {
+  if (!cp || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) return fallback;
+  return String.fromCodePoint(cp);
+}